@flusys/nestjs-entity-builder 9.0.0

package/fesm/719.js

@@ -0,0 +1,3597 @@
+export const __rspack_esm_id = 719;
+export const __rspack_esm_ids = [719];
+export const __webpack_modules__ = {
+2492(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+const FLOW_REFERENCE_PROVIDER = 'FLOW_REFERENCE_PROVIDER';
+
+__webpack_require__.d(__webpack_exports__, {
+}, {
+  $: FLOW_REFERENCE_PROVIDER
+});
+
+
+},
+2931(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+/* import */ var _flusys_nestjs_shared_classes__rspack_import_0 = __webpack_require__(6937);
+/* import */ var _flusys_nestjs_shared_modules__rspack_import_1 = __webpack_require__(1236);
+/* import */ var _nestjs_common__rspack_import_2 = __webpack_require__(6157);
+/* import */ var _config_event_actions_js__rspack_import_3 = __webpack_require__(982);
+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);
+    };
+}
+
+
+
+
+/** Every cached definition list/get. Schema changes write these rows inside a transaction, past the cached services. */ const CACHED_DEFINITIONS = [
+    _config_event_actions_js__rspack_import_3/* .ENTITY_BUILDER_EVENT_ENTITIES.ENTITY_DEFINITION */.P.ENTITY_DEFINITION,
+    _config_event_actions_js__rspack_import_3/* .ENTITY_BUILDER_EVENT_ENTITIES.FIELD_DEFINITION */.P.FIELD_DEFINITION,
+    _config_event_actions_js__rspack_import_3/* .ENTITY_BUILDER_EVENT_ENTITIES.FLOW_DEFINITION */.P.FLOW_DEFINITION
+];
+class DefinitionCacheService {
+    cacheManager;
+    utilsService;
+    constructor(cacheManager, utilsService){
+        this.cacheManager = cacheManager;
+        this.utilsService = utilsService;
+    }
+    /** `tenantId` is the tenant whose definitions changed (see `cacheTenantId`); caches are keyed per tenant. */ async clearAll(tenantId) {
+        await Promise.all(CACHED_DEFINITIONS.map((name)=>this.utilsService.clearCache(name, this.cacheManager, undefined, tenantId)));
+    }
+}
+DefinitionCacheService = _ts_decorate([
+    (0,_nestjs_common__rspack_import_2.Injectable)(),
+    _ts_param(0, (0,_nestjs_common__rspack_import_2.Inject)('CACHE_INSTANCE')),
+    _ts_param(1, (0,_nestjs_common__rspack_import_2.Inject)(_flusys_nestjs_shared_modules__rspack_import_1.UtilsService)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _flusys_nestjs_shared_classes__rspack_import_0.HybridCache === "undefined" ? Object : _flusys_nestjs_shared_classes__rspack_import_0.HybridCache,
+        typeof _flusys_nestjs_shared_modules__rspack_import_1.UtilsService === "undefined" ? Object : _flusys_nestjs_shared_modules__rspack_import_1.UtilsService
+    ])
+], DefinitionCacheService);
+
+__webpack_require__.d(__webpack_exports__, {
+  V: () => (DefinitionCacheService)
+});
+
+
+},
+1296(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+/* import */ var _flusys_nestjs_shared_classes__rspack_import_0 = __webpack_require__(6937);
+/* import */ var _flusys_nestjs_shared_modules__rspack_import_1 = __webpack_require__(1236);
+/* import */ var _nestjs_common__rspack_import_2 = __webpack_require__(6157);
+/* import */ var _config_event_actions_js__rspack_import_5 = __webpack_require__(982);
+/* import */ var _entities_entity_definition_entity_js__rspack_import_3 = __webpack_require__(3189);
+/* import */ var _entity_builder_datasource_provider_js__rspack_import_4 = __webpack_require__(424);
+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 EntityDefinitionService extends _flusys_nestjs_shared_classes__rspack_import_0.ApiService {
+    cacheManager;
+    utilsService;
+    constructor(cacheManager, utilsService, dataSourceProvider){
+        super(_config_event_actions_js__rspack_import_5/* .ENTITY_BUILDER_EVENT_ENTITIES.ENTITY_DEFINITION */.P.ENTITY_DEFINITION, cacheManager, utilsService, EntityDefinitionService.name, true, _config_event_actions_js__rspack_import_5/* .ENTITY_BUILDER_EVENT_MODULE */.S, dataSourceProvider, _entities_entity_definition_entity_js__rspack_import_3/* .EntityDefinition */.f), this.cacheManager = cacheManager, this.utilsService = utilsService;
+    }
+    // Schema changes send the loaded `updatedAt` back as `expectedUpdatedAt`; Identity hides it by default.
+    async getSelectQuery(query, user, select) {
+        const result = await super.getSelectQuery(query, user, select);
+        result.query.addSelect(`${this.entityName}.updatedAt`);
+        return result;
+    }
+}
+EntityDefinitionService = _ts_decorate([
+    (0,_nestjs_common__rspack_import_2.Injectable)({
+        scope: _nestjs_common__rspack_import_2.Scope.REQUEST
+    }),
+    _ts_param(0, (0,_nestjs_common__rspack_import_2.Inject)('CACHE_INSTANCE')),
+    _ts_param(1, (0,_nestjs_common__rspack_import_2.Inject)(_flusys_nestjs_shared_modules__rspack_import_1.UtilsService)),
+    _ts_param(2, (0,_nestjs_common__rspack_import_2.Inject)(_entity_builder_datasource_provider_js__rspack_import_4/* .EntityBuilderDataSourceProvider */.D)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _flusys_nestjs_shared_classes__rspack_import_0.HybridCache === "undefined" ? Object : _flusys_nestjs_shared_classes__rspack_import_0.HybridCache,
+        typeof _flusys_nestjs_shared_modules__rspack_import_1.UtilsService === "undefined" ? Object : _flusys_nestjs_shared_modules__rspack_import_1.UtilsService,
+        typeof _entity_builder_datasource_provider_js__rspack_import_4/* .EntityBuilderDataSourceProvider */.D === "undefined" ? Object : _entity_builder_datasource_provider_js__rspack_import_4/* .EntityBuilderDataSourceProvider */.D
+    ])
+], EntityDefinitionService);
+
+__webpack_require__.d(__webpack_exports__, {
+  o: () => (EntityDefinitionService)
+});
+
+
+},
+8271(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+/* import */ var _config_message_keys_js__rspack_import_2 = __webpack_require__(5732);
+/* import */ var _enums_field_type_enum_js__rspack_import_1 = __webpack_require__(9614);
+/* import */ var _flow_engine_flow_types_js__rspack_import_0 = __webpack_require__(6256);
+
+
+
+/** The path of each endpoint's Request step: `api-flows/<entity>/<path>`. */ const ENTITY_FLOW_PATHS = {
+    insert: 'insert',
+    insertMany: 'insert-many',
+    getById: 'get-by-id',
+    getByIds: 'get-by-ids',
+    getAll: 'get-all',
+    getByFilter: 'get-by-filter',
+    update: 'update',
+    updateMany: 'update-many',
+    bulkUpsert: 'bulk-upsert',
+    delete: 'delete'
+};
+const DEFAULT_ENDPOINT_NAME = {
+    insert: 'Insert',
+    insertMany: 'Insert many',
+    getById: 'Get by id',
+    getByIds: 'Get by ids',
+    getAll: 'Get all',
+    getByFilter: 'Get by filter',
+    update: 'Update',
+    updateMany: 'Update many',
+    bulkUpsert: 'Bulk upsert',
+    delete: 'Delete'
+};
+const DEFAULT_INPUT_LABEL = {
+    id: 'Id',
+    ids: 'Ids',
+    search: 'Search'
+};
+const DEFAULT_NO_MATCH_MESSAGE = 'No record matches the filter.';
+const MAX_NAME_LENGTH = 255;
+/** A supplied text when it has content, the English default otherwise. */ const textOr = (value, fallback)=>value?.trim() || fallback;
+const INPUT_TYPE = {
+    [_enums_field_type_enum_js__rspack_import_1/* .FieldType.TEXT */.P.TEXT]: 'string',
+    [_enums_field_type_enum_js__rspack_import_1/* .FieldType.LONG_TEXT */.P.LONG_TEXT]: 'text',
+    [_enums_field_type_enum_js__rspack_import_1/* .FieldType.INTEGER */.P.INTEGER]: 'integer',
+    [_enums_field_type_enum_js__rspack_import_1/* .FieldType.DECIMAL */.P.DECIMAL]: 'number',
+    [_enums_field_type_enum_js__rspack_import_1/* .FieldType.BOOLEAN */.P.BOOLEAN]: 'boolean',
+    [_enums_field_type_enum_js__rspack_import_1/* .FieldType.DATE */.P.DATE]: 'date',
+    [_enums_field_type_enum_js__rspack_import_1/* .FieldType.DATETIME */.P.DATETIME]: 'datetime',
+    [_enums_field_type_enum_js__rspack_import_1/* .FieldType.EMAIL */.P.EMAIL]: 'email',
+    [_enums_field_type_enum_js__rspack_import_1/* .FieldType.SINGLE_SELECT */.P.SINGLE_SELECT]: 'choice',
+    [_enums_field_type_enum_js__rspack_import_1/* .FieldType.MULTI_SELECT */.P.MULTI_SELECT]: 'array',
+    [_enums_field_type_enum_js__rspack_import_1/* .FieldType.RELATION */.P.RELATION]: 'uuid',
+    [_enums_field_type_enum_js__rspack_import_1/* .FieldType.JSON */.P.JSON]: 'object',
+    [_enums_field_type_enum_js__rspack_import_1/* .FieldType.FILE */.P.FILE]: 'uuid'
+};
+const LIST_LIMIT = 50;
+const READ_ENDPOINTS = new Set([
+    'getById',
+    'getByIds',
+    'getAll',
+    'getByFilter'
+]);
+const COLUMN = {
+    x: 40,
+    gap: 300
+};
+const ROW = {
+    y: 60,
+    gap: 160
+};
+const ref = (path)=>({
+        type: 'field_ref',
+        ref: path
+    });
+const lit = (value)=>({
+        type: 'literal',
+        value
+    });
+/** `customer_ticket` -> `customer-ticket`: an entity code always fits a flow URL name. */ const entityFlowSlug = (entityCode)=>entityCode.replace(/_/g, '-');
+function optionValues(options) {
+    return (options ?? []).map((o)=>o && typeof o === 'object' && 'value' in o ? String(o.value) : String(o));
+}
+const NUMERIC_TYPES = new Set([
+    _enums_field_type_enum_js__rspack_import_1/* .FieldType.INTEGER */.P.INTEGER,
+    _enums_field_type_enum_js__rspack_import_1/* .FieldType.DECIMAL */.P.DECIMAL
+]);
+const TEXT_TYPES = new Set([
+    _enums_field_type_enum_js__rspack_import_1/* .FieldType.TEXT */.P.TEXT,
+    _enums_field_type_enum_js__rspack_import_1/* .FieldType.LONG_TEXT */.P.LONG_TEXT,
+    _enums_field_type_enum_js__rspack_import_1/* .FieldType.EMAIL */.P.EMAIL
+]);
+/** The field's rules a Request body checks the same way the record write does. */ function inputRules(field) {
+    const rules = field.validationRules ?? {};
+    const keys = NUMERIC_TYPES.has(field.fieldType) ? [
+        'min',
+        'max'
+    ] : TEXT_TYPES.has(field.fieldType) ? [
+        'minLength',
+        'maxLength'
+    ] : [];
+    return Object.fromEntries(keys.filter((key)=>typeof rules[key] === 'number' && Number.isFinite(rules[key])).map((key)=>[
+            key,
+            rules[key]
+        ]));
+}
+/**
+ * The Request body input of a field: a choice carries its options, a multi-select is a list of
+ * those choices, a relation or file is an id. `rules`: a write also checks the field's own value rules.
+ */ function fieldInput(field, required, rules = true) {
+    const options = optionValues(field.selectOptions);
+    const base = {
+        name: field.code,
+        label: field.label || field.code,
+        ...required ? {
+            required: true
+        } : {},
+        ...rules ? inputRules(field) : {}
+    };
+    if (field.fieldType === _enums_field_type_enum_js__rspack_import_1/* .FieldType.MULTI_SELECT */.P.MULTI_SELECT) return {
+        ...base,
+        type: 'array',
+        ...options.length ? {
+            itemType: 'choice',
+            options
+        } : {
+            itemType: 'string'
+        }
+    };
+    const type = INPUT_TYPE[field.fieldType] === 'choice' && !options.length ? 'string' : INPUT_TYPE[field.fieldType];
+    return {
+        ...base,
+        type,
+        ...type === 'choice' ? {
+            options
+        } : {}
+    };
+}
+const isRequiredOnInsert = (field)=>field.nullable === false && (field.defaultValue === null || field.defaultValue === undefined);
+const fieldMap = (fields, scope)=>Object.fromEntries(fields.map((f)=>[
+            f.code,
+            ref(`${scope}.${f.code}`)
+        ]));
+const optionalFieldInputs = (fields)=>fields.map((f)=>fieldInput(f, false));
+/** Inputs of a read filter: only the value's type is checked, never the write rules. */ const filterInputs = (fields)=>fields.map((f)=>fieldInput(f, false, false));
+/** Fields an equality filter can match - a list or JSON value cannot be compared as one value. */ const filterableFields = (entity)=>entity.fields.filter((f)=>f.fieldType !== _enums_field_type_enum_js__rspack_import_1/* .FieldType.MULTI_SELECT */.P.MULTI_SELECT && f.fieldType !== _enums_field_type_enum_js__rspack_import_1/* .FieldType.JSON */.P.JSON);
+const idInput = (t)=>({
+        name: 'id',
+        label: t.inputLabels.id,
+        type: 'uuid',
+        required: true
+    });
+const idsInput = (t)=>({
+        name: 'ids',
+        label: t.inputLabels.ids,
+        type: 'array',
+        itemType: 'uuid',
+        required: true
+    });
+const respond = (id, column, statusCode, body, row)=>({
+        id,
+        type: 'respond',
+        column,
+        row,
+        config: 'type' in body ? {
+            statusCode,
+            bodyExpression: body
+        } : {
+            statusCode,
+            body
+        }
+    });
+/**
+ * The steps of one endpoint. Its step ids are `<endpoint>_<step>` (`id()`), so the endpoints of one
+ * flow never share a step. A bulk body is the list itself (`itemSchema` checks each item), written by
+ * one step that walks it (`target: many`, each item read as `loop.item`), all or nothing, and
+ * answered with the saved records in order.
+ */ function endpointGraph(entity, endpoint, texts) {
+    const id = (step)=>`${endpoint}_${step}`;
+    const entityCode = entity.code;
+    const single = (inputSchema, step, statusCode = 200)=>({
+            inputSchema,
+            steps: [
+                {
+                    ...step,
+                    id: id('record'),
+                    column: 1
+                },
+                respond(id('respond'), 2, statusCode, ref(`context.${id('record')}`))
+            ],
+            edges: [
+                [
+                    id('record'),
+                    'out',
+                    id('respond')
+                ]
+            ]
+        });
+    const bulk = (itemSchema, step, statusCode)=>({
+            bodyType: 'list',
+            inputSchema: itemSchema,
+            steps: [
+                {
+                    ...step,
+                    id: id('records'),
+                    column: 1,
+                    config: {
+                        ...step.config,
+                        target: 'many',
+                        items: ref('input')
+                    }
+                },
+                respond(id('respond'), 2, statusCode, ref(`context.${id('records')}.items`))
+            ],
+            edges: [
+                [
+                    id('records'),
+                    'out',
+                    id('respond')
+                ]
+            ]
+        });
+    const filterFields = filterableFields(entity);
+    const insertInputs = entity.fields.map((f)=>fieldInput(f, isRequiredOnInsert(f)));
+    switch(endpoint){
+        case 'insert':
+            return single(insertInputs, {
+                type: 'entity_insert',
+                config: {
+                    entityCode,
+                    fields: fieldMap(entity.fields, 'input')
+                }
+            }, 201);
+        case 'insertMany':
+            return bulk(insertInputs, {
+                type: 'entity_insert',
+                config: {
+                    entityCode,
+                    fields: fieldMap(entity.fields, 'loop.item')
+                }
+            }, 201);
+        case 'getById':
+            return single([
+                idInput(texts)
+            ], {
+                type: 'entity_get',
+                config: {
+                    entityCode,
+                    id: ref('input.id')
+                }
+            });
+        case 'getByIds':
+            return single([
+                idsInput(texts)
+            ], {
+                type: 'entity_query',
+                config: {
+                    entityCode,
+                    filter: {
+                        id: {
+                            op: 'in',
+                            value: ref('input.ids')
+                        }
+                    },
+                    limit: _flow_engine_flow_types_js__rspack_import_0/* .FLOW_LIMITS.MAX_QUERY_LIMIT */.Or.MAX_QUERY_LIMIT
+                }
+            });
+        case 'getAll':
+            return single([
+                {
+                    name: 'search',
+                    label: texts.inputLabels.search,
+                    type: 'string'
+                },
+                ...filterInputs(filterFields)
+            ], {
+                type: 'entity_query',
+                config: {
+                    entityCode,
+                    search: ref('input.search'),
+                    filter: fieldMap(filterFields, 'input'),
+                    limit: LIST_LIMIT
+                }
+            });
+        case 'getByFilter':
+            return {
+                inputSchema: [
+                    {
+                        ...idInput(texts),
+                        required: false
+                    },
+                    ...filterInputs(filterFields)
+                ],
+                steps: [
+                    {
+                        id: id('records'),
+                        type: 'entity_query',
+                        column: 1,
+                        config: {
+                            entityCode,
+                            filter: {
+                                id: ref('input.id'),
+                                ...fieldMap(filterFields, 'input')
+                            },
+                            limit: 1
+                        }
+                    },
+                    {
+                        id: id('found'),
+                        type: 'condition',
+                        column: 2,
+                        config: {
+                            rule: {
+                                operator: 'AND',
+                                conditions: [
+                                    {
+                                        field: `context.${id('records')}.items`,
+                                        comparison: 'is_not_empty'
+                                    }
+                                ]
+                            }
+                        }
+                    },
+                    respond(id('respond'), 3, 200, ref(`context.${id('records')}.items.0`)),
+                    respond(id('not_found'), 3, 404, {
+                        success: lit(false),
+                        message: lit(texts.noMatchMessage),
+                        messageKey: lit(_config_message_keys_js__rspack_import_2/* .GENERIC_RECORD_MESSAGES.NO_MATCH */.j4.NO_MATCH)
+                    }, 1)
+                ],
+                edges: [
+                    [
+                        id('records'),
+                        'out',
+                        id('found')
+                    ],
+                    [
+                        id('found'),
+                        'true',
+                        id('respond')
+                    ],
+                    [
+                        id('found'),
+                        'false',
+                        id('not_found')
+                    ]
+                ]
+            };
+        case 'update':
+            return single([
+                idInput(texts),
+                ...optionalFieldInputs(entity.fields)
+            ], {
+                type: 'entity_update',
+                config: {
+                    entityCode,
+                    id: ref('input.id'),
+                    fields: fieldMap(entity.fields, 'input')
+                }
+            });
+        case 'updateMany':
+            return bulk([
+                idInput(texts),
+                ...optionalFieldInputs(entity.fields)
+            ], {
+                type: 'entity_update',
+                config: {
+                    entityCode,
+                    fields: fieldMap(entity.fields, 'loop.item')
+                }
+            }, 200);
+        case 'bulkUpsert':
+            return bulk([
+                {
+                    ...idInput(texts),
+                    required: false
+                },
+                ...optionalFieldInputs(entity.fields)
+            ], {
+                type: 'entity_update',
+                config: {
+                    entityCode,
+                    fields: fieldMap(entity.fields, 'loop.item'),
+                    onNotFound: 'insert'
+                }
+            }, 200);
+        case 'delete':
+            return single([
+                idInput(texts)
+            ], {
+                type: 'entity_delete',
+                config: {
+                    entityCode,
+                    id: ref('input.id')
+                }
+            });
+    }
+}
+/**
+ * The ready-made flow of an entity: `api-flows/<entity>` with one Request step per endpoint of the
+ * generic API controller, each on its own path (`ENTITY_FLOW_PATHS`) with its own body, laid out
+ * one below the other. Each runs as the caller, so the entity permissions still decide who may use
+ * it, and it is an ordinary flow afterwards - the user can change or delete it like any other. A
+ * write endpoint is transactional: a bulk endpoint writes its whole list in one step, so a failing
+ * item rolls back the whole request; a read endpoint opens none. A bulk body holds at most
+ * FLOW_LIMITS.MAX_WRITE_ITEMS items.
+ */ function buildEntityFlow(entity, endpoints, texts = {}) {
+    const resolved = {
+        inputLabels: {
+            id: textOr(texts.inputLabels?.id, DEFAULT_INPUT_LABEL.id),
+            ids: textOr(texts.inputLabels?.ids, DEFAULT_INPUT_LABEL.ids),
+            search: textOr(texts.inputLabels?.search, DEFAULT_INPUT_LABEL.search)
+        },
+        noMatchMessage: textOr(texts.noMatchMessage, DEFAULT_NO_MATCH_MESSAGE)
+    };
+    const nodes = [];
+    const edges = [];
+    let band = 0;
+    for (const endpoint of endpoints){
+        const graph = endpointGraph(entity, endpoint, resolved);
+        const at = (column, row = 0)=>({
+                x: COLUMN.x + column * COLUMN.gap,
+                y: ROW.y + (band + row) * ROW.gap
+            });
+        const config = {
+            path: ENTITY_FLOW_PATHS[endpoint],
+            bodyType: graph.bodyType ?? 'object',
+            inputSchema: graph.inputSchema,
+            ...READ_ENDPOINTS.has(endpoint) ? {} : {
+                isTransactional: true
+            }
+        };
+        nodes.push({
+            id: endpoint,
+            type: 'trigger',
+            name: textOr(texts.names?.[endpoint], DEFAULT_ENDPOINT_NAME[endpoint]).slice(0, MAX_NAME_LENGTH),
+            position: at(0),
+            config
+        }, ...graph.steps.map(({ column, row, ...step })=>({
+                ...step,
+                name: '',
+                position: at(column, row)
+            })));
+        edges.push(...[
+            [
+                endpoint,
+                'out',
+                graph.steps[0].id
+            ],
+            ...graph.edges
+        ].map(([from, port, to])=>({
+                id: `e_${from}_${port}_${to}`,
+                from,
+                port,
+                to
+            })));
+        band += 1 + Math.max(0, ...graph.steps.map((step)=>step.row ?? 0));
+    }
+    return {
+        name: entity.label.slice(0, MAX_NAME_LENGTH),
+        slug: entityFlowSlug(entity.code),
+        isActive: true,
+        nodes,
+        edges
+    };
+}
+
+__webpack_require__.d(__webpack_exports__, {
+  CO: () => (buildEntityFlow)
+}, {
+  IP: ENTITY_FLOW_PATHS,
+  x2: entityFlowSlug
+});
+
+
+},
+1462(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+/* import */ var _flusys_nestjs_shared__rspack_import_0 = __webpack_require__(3422);
+/* import */ var _nestjs_common__rspack_import_1 = __webpack_require__(6157);
+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 CRUD_ACTIONS = [
+    'create',
+    'read',
+    'update',
+    'delete'
+];
+class EntityPermissionService {
+    actionRegistry;
+    constructor(actionRegistry){
+        this.actionRegistry = actionRegistry;
+    }
+    async provisionForEntity(definition) {
+        if (!this.actionRegistry) return;
+        const parentCode = (0,_flusys_nestjs_shared__rspack_import_0.dynamicEntityPermissionParent)(definition.code);
+        await this.actionRegistry.registerActions(CRUD_ACTIONS.map((op)=>({
+                code: (0,_flusys_nestjs_shared__rspack_import_0.dynamicEntityPermission)(definition.code, op),
+                name: `${definition.label} - ${op}`,
+                parentCode,
+                actionType: 'BACKEND'
+            })));
+    }
+    async deprovisionForEntity(definition) {
+        if (!this.actionRegistry) return;
+        await this.actionRegistry.removeActionsByCodes([
+            (0,_flusys_nestjs_shared__rspack_import_0.dynamicEntityPermissionParent)(definition.code),
+            ...CRUD_ACTIONS.map((op)=>(0,_flusys_nestjs_shared__rspack_import_0.dynamicEntityPermission)(definition.code, op))
+        ]);
+    }
+}
+EntityPermissionService = _ts_decorate([
+    (0,_nestjs_common__rspack_import_1.Injectable)(),
+    _ts_param(0, (0,_nestjs_common__rspack_import_1.Optional)()),
+    _ts_param(0, (0,_nestjs_common__rspack_import_1.Inject)(_flusys_nestjs_shared__rspack_import_0.PERMISSION_ACTION_REGISTRY)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof IPermissionActionRegistry === "undefined" ? Object : IPermissionActionRegistry
+    ])
+], EntityPermissionService);
+
+__webpack_require__.d(__webpack_exports__, {
+  u: () => (EntityPermissionService)
+});
+
+
+},
+9487(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+/* import */ var _flusys_nestjs_shared_classes__rspack_import_0 = __webpack_require__(6937);
+/* import */ var _flusys_nestjs_shared_modules__rspack_import_1 = __webpack_require__(1236);
+/* import */ var _nestjs_common__rspack_import_2 = __webpack_require__(6157);
+/* import */ var _config_event_actions_js__rspack_import_5 = __webpack_require__(982);
+/* import */ var _entities_field_definition_entity_js__rspack_import_3 = __webpack_require__(2206);
+/* import */ var _entity_builder_datasource_provider_js__rspack_import_4 = __webpack_require__(424);
+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 FieldDefinitionService extends _flusys_nestjs_shared_classes__rspack_import_0.ApiService {
+    cacheManager;
+    utilsService;
+    constructor(cacheManager, utilsService, dataSourceProvider){
+        super(_config_event_actions_js__rspack_import_5/* .ENTITY_BUILDER_EVENT_ENTITIES.FIELD_DEFINITION */.P.FIELD_DEFINITION, cacheManager, utilsService, FieldDefinitionService.name, true, _config_event_actions_js__rspack_import_5/* .ENTITY_BUILDER_EVENT_MODULE */.S, dataSourceProvider, _entities_field_definition_entity_js__rspack_import_3/* .FieldDefinition */.c), this.cacheManager = cacheManager, this.utilsService = utilsService;
+    }
+    // Schema changes send the loaded `updatedAt` back as `expectedUpdatedAt`; Identity hides it by default.
+    async getSelectQuery(query, user, select) {
+        const result = await super.getSelectQuery(query, user, select);
+        result.query.addSelect(`${this.entityName}.updatedAt`);
+        return result;
+    }
+}
+FieldDefinitionService = _ts_decorate([
+    (0,_nestjs_common__rspack_import_2.Injectable)({
+        scope: _nestjs_common__rspack_import_2.Scope.REQUEST
+    }),
+    _ts_param(0, (0,_nestjs_common__rspack_import_2.Inject)('CACHE_INSTANCE')),
+    _ts_param(1, (0,_nestjs_common__rspack_import_2.Inject)(_flusys_nestjs_shared_modules__rspack_import_1.UtilsService)),
+    _ts_param(2, (0,_nestjs_common__rspack_import_2.Inject)(_entity_builder_datasource_provider_js__rspack_import_4/* .EntityBuilderDataSourceProvider */.D)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _flusys_nestjs_shared_classes__rspack_import_0.HybridCache === "undefined" ? Object : _flusys_nestjs_shared_classes__rspack_import_0.HybridCache,
+        typeof _flusys_nestjs_shared_modules__rspack_import_1.UtilsService === "undefined" ? Object : _flusys_nestjs_shared_modules__rspack_import_1.UtilsService,
+        typeof _entity_builder_datasource_provider_js__rspack_import_4/* .EntityBuilderDataSourceProvider */.D === "undefined" ? Object : _entity_builder_datasource_provider_js__rspack_import_4/* .EntityBuilderDataSourceProvider */.D
+    ])
+], FieldDefinitionService);
+
+__webpack_require__.d(__webpack_exports__, {
+  J: () => (FieldDefinitionService)
+});
+
+
+},
+4984(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+/* import */ var _flusys_nestjs_shared_utils__rspack_import_0 = __webpack_require__(9216);
+/* import */ var _config_message_keys_js__rspack_import_2 = __webpack_require__(5732);
+/* import */ var _enums_field_type_enum_js__rspack_import_1 = __webpack_require__(9614);
+
+
+
+const TEXT_LIKE = new Set([
+    _enums_field_type_enum_js__rspack_import_1/* .FieldType.TEXT */.P.TEXT,
+    _enums_field_type_enum_js__rspack_import_1/* .FieldType.EMAIL */.P.EMAIL,
+    _enums_field_type_enum_js__rspack_import_1/* .FieldType.SINGLE_SELECT */.P.SINGLE_SELECT
+]);
+const SCALAR_TO_TEXT = new Set([
+    _enums_field_type_enum_js__rspack_import_1/* .FieldType.INTEGER */.P.INTEGER,
+    _enums_field_type_enum_js__rspack_import_1/* .FieldType.DECIMAL */.P.DECIMAL,
+    _enums_field_type_enum_js__rspack_import_1/* .FieldType.BOOLEAN */.P.BOOLEAN,
+    _enums_field_type_enum_js__rspack_import_1/* .FieldType.DATE */.P.DATE,
+    _enums_field_type_enum_js__rspack_import_1/* .FieldType.DATETIME */.P.DATETIME
+]);
+const EMAIL_PG = `'^[^[:space:]@]+@[^[:space:]@]+\\.[^[:space:]@]+$'`;
+const regexFail = (column, driver, pattern)=>driver === 'postgres' ? `${column} !~ '${pattern}'` : `${column} NOT REGEXP '${pattern}'`;
+const SELECT_KINDS = new Set([
+    _enums_field_type_enum_js__rspack_import_1/* .FieldType.SINGLE_SELECT */.P.SINGLE_SELECT,
+    _enums_field_type_enum_js__rspack_import_1/* .FieldType.MULTI_SELECT */.P.MULTI_SELECT
+]);
+const unsupported = (from, to)=>({
+        supported: false,
+        prechecks: [],
+        reason: (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_2/* .SCHEMA_BLOCKER_MESSAGES.CONVERSION_UNSUPPORTED */.M3.CONVERSION_UNSUPPORTED, {
+            from,
+            to
+        })
+    });
+function planTypeConversion(from, to, driver) {
+    if (from === to) return {
+        supported: true,
+        noDbChange: true,
+        prechecks: []
+    };
+    // MySQL has no USING clause: MODIFY casts implicitly, which rejects text as JSON or boolean and would keep a JSON array as its text.
+    const textLike = TEXT_LIKE.has(from) || from === _enums_field_type_enum_js__rspack_import_1/* .FieldType.LONG_TEXT */.P.LONG_TEXT;
+    if (driver === 'mysql' && (SELECT_KINDS.has(from) && SELECT_KINDS.has(to) || textLike && to === _enums_field_type_enum_js__rspack_import_1/* .FieldType.BOOLEAN */.P.BOOLEAN)) return unsupported(from, to);
+    // Same physical column (varchar(255)): only the meaning changes.
+    if (TEXT_LIKE.has(from) && TEXT_LIKE.has(to)) {
+        const checks = [];
+        if (to === _enums_field_type_enum_js__rspack_import_1/* .FieldType.EMAIL */.P.EMAIL) {
+            checks.push({
+                description: (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_2/* .SCHEMA_PRECHECK_MESSAGES.NOT_EMAIL */.NE.NOT_EMAIL),
+                badRowsWhere: (c, d)=>d === 'postgres' ? `${c} !~ ${EMAIL_PG}` : `${c} NOT REGEXP '^[^ @]+@[^ @]+\\\\.[^ @]+$'`
+            });
+        }
+        return {
+            supported: true,
+            noDbChange: true,
+            prechecks: checks
+        };
+    }
+    if (from === _enums_field_type_enum_js__rspack_import_1/* .FieldType.RELATION */.P.RELATION && to === _enums_field_type_enum_js__rspack_import_1/* .FieldType.FILE */.P.FILE || from === _enums_field_type_enum_js__rspack_import_1/* .FieldType.FILE */.P.FILE && to === _enums_field_type_enum_js__rspack_import_1/* .FieldType.RELATION */.P.RELATION) {
+        return {
+            supported: true,
+            noDbChange: true,
+            prechecks: []
+        };
+    }
+    // -> LONG_TEXT (text): widening from everything scalar/text-like
+    if (to === _enums_field_type_enum_js__rspack_import_1/* .FieldType.LONG_TEXT */.P.LONG_TEXT && (TEXT_LIKE.has(from) || SCALAR_TO_TEXT.has(from))) {
+        return {
+            supported: true,
+            using: (c)=>`${c}::text`,
+            prechecks: []
+        };
+    }
+    // LONG_TEXT -> varchar(255) kinds: narrowing, blocked if any value is too long
+    if (from === _enums_field_type_enum_js__rspack_import_1/* .FieldType.LONG_TEXT */.P.LONG_TEXT && TEXT_LIKE.has(to)) {
+        const checks = [
+            {
+                description: (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_2/* .SCHEMA_PRECHECK_MESSAGES.TOO_LONG */.NE.TOO_LONG),
+                badRowsWhere: (c, d)=>d === 'postgres' ? `char_length(${c}) > 255` : `CHAR_LENGTH(${c}) > 255`
+            }
+        ];
+        if (to === _enums_field_type_enum_js__rspack_import_1/* .FieldType.EMAIL */.P.EMAIL) {
+            checks.push({
+                description: (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_2/* .SCHEMA_PRECHECK_MESSAGES.NOT_EMAIL */.NE.NOT_EMAIL),
+                badRowsWhere: (c, d)=>d === 'postgres' ? `${c} !~ ${EMAIL_PG}` : `${c} NOT REGEXP '^[^ @]+@[^ @]+\\\\.[^ @]+$'`
+            });
+        }
+        return {
+            supported: true,
+            using: (c)=>`${c}::varchar(255)`,
+            prechecks: checks
+        };
+    }
+    // scalar -> text-like: always representable
+    if (SCALAR_TO_TEXT.has(from) && TEXT_LIKE.has(to)) {
+        const checks = [];
+        if (to === _enums_field_type_enum_js__rspack_import_1/* .FieldType.EMAIL */.P.EMAIL) {
+            checks.push({
+                description: (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_2/* .SCHEMA_PRECHECK_MESSAGES.NOT_EMAIL */.NE.NOT_EMAIL),
+                badRowsWhere: (c, d)=>d === 'postgres' ? `${c}::text !~ ${EMAIL_PG}` : `CAST(${c} AS CHAR) NOT REGEXP '^[^ @]+@[^ @]+\\\\.[^ @]+$'`
+            });
+        }
+        return {
+            supported: true,
+            using: (c)=>`${c}::text`,
+            prechecks: checks
+        };
+    }
+    // text-like / long text -> scalar: every existing value must parse
+    if (textLike) {
+        switch(to){
+            case _enums_field_type_enum_js__rspack_import_1/* .FieldType.INTEGER */.P.INTEGER:
+                return {
+                    supported: true,
+                    using: (c)=>`${c}::integer`,
+                    prechecks: [
+                        {
+                            description: (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_2/* .SCHEMA_PRECHECK_MESSAGES.NOT_WHOLE_NUMBER */.NE.NOT_WHOLE_NUMBER),
+                            badRowsWhere: (c, d)=>regexFail(c, d, '^-?[0-9]{1,10}$')
+                        }
+                    ]
+                };
+            case _enums_field_type_enum_js__rspack_import_1/* .FieldType.DECIMAL */.P.DECIMAL:
+                return {
+                    supported: true,
+                    using: (c)=>`${c}::numeric(18,4)`,
+                    prechecks: [
+                        {
+                            description: (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_2/* .SCHEMA_PRECHECK_MESSAGES.NOT_NUMBER */.NE.NOT_NUMBER),
+                            badRowsWhere: (c, d)=>regexFail(c, d, '^-?[0-9]{1,14}(\\.[0-9]+)?$')
+                        }
+                    ]
+                };
+            case _enums_field_type_enum_js__rspack_import_1/* .FieldType.BOOLEAN */.P.BOOLEAN:
+                return {
+                    supported: true,
+                    using: (c)=>`(lower(${c}))::boolean`,
+                    prechecks: [
+                        {
+                            description: (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_2/* .SCHEMA_PRECHECK_MESSAGES.NOT_BOOLEAN_TEXT */.NE.NOT_BOOLEAN_TEXT),
+                            badRowsWhere: (c)=>`lower(${c}) NOT IN ('true','false')`
+                        }
+                    ]
+                };
+            case _enums_field_type_enum_js__rspack_import_1/* .FieldType.DATE */.P.DATE:
+                return {
+                    supported: true,
+                    using: (c)=>`${c}::date`,
+                    prechecks: [
+                        {
+                            description: (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_2/* .SCHEMA_PRECHECK_MESSAGES.NOT_DATE */.NE.NOT_DATE),
+                            badRowsWhere: (c, d)=>regexFail(c, d, '^[0-9]{4}-[0-9]{2}-[0-9]{2}$')
+                        }
+                    ]
+                };
+            case _enums_field_type_enum_js__rspack_import_1/* .FieldType.DATETIME */.P.DATETIME:
+                return {
+                    supported: true,
+                    using: (c)=>`${c}::timestamptz`,
+                    prechecks: [
+                        {
+                            description: (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_2/* .SCHEMA_PRECHECK_MESSAGES.NOT_DATETIME */.NE.NOT_DATETIME),
+                            badRowsWhere: (c, d)=>regexFail(c, d, d === 'postgres' ? '^[0-9]{4}-[0-9]{2}-[0-9]{2}([T ][0-9:.]+)?(Z|[+-][0-9:]+)?$' : '^[0-9]{4}-[0-9]{2}-[0-9]{2}([T ][0-9]{2}:[0-9]{2}(:[0-9]{2}(\\.[0-9]+)?)?)?$')
+                        }
+                    ]
+                };
+            default:
+                break;
+        }
+    }
+    // numeric conversions
+    if (from === _enums_field_type_enum_js__rspack_import_1/* .FieldType.INTEGER */.P.INTEGER && to === _enums_field_type_enum_js__rspack_import_1/* .FieldType.DECIMAL */.P.DECIMAL) return {
+        supported: true,
+        using: (c)=>`${c}::numeric(18,4)`,
+        prechecks: []
+    };
+    if (from === _enums_field_type_enum_js__rspack_import_1/* .FieldType.DECIMAL */.P.DECIMAL && to === _enums_field_type_enum_js__rspack_import_1/* .FieldType.INTEGER */.P.INTEGER) {
+        return {
+            supported: true,
+            using: (c)=>`round(${c})::integer`,
+            lossy: (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_2/* .SCHEMA_WARNING_MESSAGES.LOSSY_ROUNDING */.Uu.LOSSY_ROUNDING),
+            prechecks: [
+                {
+                    description: (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_2/* .SCHEMA_PRECHECK_MESSAGES.OUT_OF_INTEGER_RANGE */.NE.OUT_OF_INTEGER_RANGE),
+                    badRowsWhere: (c)=>`abs(${c}) > 2147483647`
+                }
+            ]
+        };
+    }
+    if ((from === _enums_field_type_enum_js__rspack_import_1/* .FieldType.INTEGER */.P.INTEGER || from === _enums_field_type_enum_js__rspack_import_1/* .FieldType.DECIMAL */.P.DECIMAL) && to === _enums_field_type_enum_js__rspack_import_1/* .FieldType.BOOLEAN */.P.BOOLEAN) {
+        return {
+            supported: true,
+            using: (c)=>`(${c} <> 0)`,
+            prechecks: [
+                {
+                    description: (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_2/* .SCHEMA_PRECHECK_MESSAGES.NOT_ZERO_OR_ONE */.NE.NOT_ZERO_OR_ONE),
+                    badRowsWhere: (c)=>`${c} NOT IN (0,1)`
+                }
+            ]
+        };
+    }
+    if (from === _enums_field_type_enum_js__rspack_import_1/* .FieldType.BOOLEAN */.P.BOOLEAN && (to === _enums_field_type_enum_js__rspack_import_1/* .FieldType.INTEGER */.P.INTEGER || to === _enums_field_type_enum_js__rspack_import_1/* .FieldType.DECIMAL */.P.DECIMAL)) {
+        return {
+            supported: true,
+            using: (c)=>to === _enums_field_type_enum_js__rspack_import_1/* .FieldType.INTEGER */.P.INTEGER ? `${c}::integer` : `${c}::integer::numeric(18,4)`,
+            prechecks: []
+        };
+    }
+    // dates
+    if (from === _enums_field_type_enum_js__rspack_import_1/* .FieldType.DATE */.P.DATE && to === _enums_field_type_enum_js__rspack_import_1/* .FieldType.DATETIME */.P.DATETIME) return {
+        supported: true,
+        using: (c)=>`${c}::timestamptz`,
+        prechecks: []
+    };
+    if (from === _enums_field_type_enum_js__rspack_import_1/* .FieldType.DATETIME */.P.DATETIME && to === _enums_field_type_enum_js__rspack_import_1/* .FieldType.DATE */.P.DATE) {
+        return {
+            supported: true,
+            using: (c)=>`${c}::date`,
+            lossy: (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_2/* .SCHEMA_WARNING_MESSAGES.LOSSY_TIME_DROPPED */.Uu.LOSSY_TIME_DROPPED),
+            prechecks: []
+        };
+    }
+    // select <-> multi select
+    if (from === _enums_field_type_enum_js__rspack_import_1/* .FieldType.SINGLE_SELECT */.P.SINGLE_SELECT && to === _enums_field_type_enum_js__rspack_import_1/* .FieldType.MULTI_SELECT */.P.MULTI_SELECT) {
+        return {
+            supported: true,
+            using: (c)=>`CASE WHEN ${c} IS NULL THEN NULL ELSE jsonb_build_array(${c}) END`,
+            prechecks: []
+        };
+    }
+    if (from === _enums_field_type_enum_js__rspack_import_1/* .FieldType.MULTI_SELECT */.P.MULTI_SELECT && to === _enums_field_type_enum_js__rspack_import_1/* .FieldType.SINGLE_SELECT */.P.SINGLE_SELECT) {
+        return {
+            supported: true,
+            using: (c)=>`${c}->>0`,
+            prechecks: [
+                {
+                    description: (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_2/* .SCHEMA_PRECHECK_MESSAGES.MULTIPLE_SELECTED */.NE.MULTIPLE_SELECTED),
+                    badRowsWhere: (c)=>`jsonb_array_length(${c}) > 1`
+                }
+            ]
+        };
+    }
+    return unsupported(from, to);
+}
+
+__webpack_require__.d(__webpack_exports__, {
+  I: () => (planTypeConversion)
+});
+
+
+},
+413(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+/* import */ var _nestjs_common__rspack_import_0 = __webpack_require__(6157);
+/* import */ var _config_message_keys_js__rspack_import_3 = __webpack_require__(5732);
+/* import */ var _config_entity_builder_constants_js__rspack_import_2 = __webpack_require__(6576);
+/* import */ var _config_event_actions_js__rspack_import_4 = __webpack_require__(982);
+/* import */ var _schema_columns_js__rspack_import_1 = __webpack_require__(5313);
+
+
+
+
+
+/**
+ * SQL reserved words relevant to table/column identifiers (ANSI/Postgres/MySQL keywords most
+ * likely to collide with a user-chosen code). Not exhaustive - the `eb_` table prefix, the
+ * identifier pattern and the live "table exists" check are defense in depth.
+ */ const RESERVED_WORDS = new Set([
+    'select',
+    'insert',
+    'update',
+    'delete',
+    'from',
+    'where',
+    'table',
+    'index',
+    'key',
+    'primary',
+    'foreign',
+    'references',
+    'default',
+    'null',
+    'true',
+    'false',
+    'user',
+    'role',
+    'grant',
+    'revoke',
+    'database',
+    'schema',
+    'view',
+    'trigger',
+    'function',
+    'procedure',
+    'constraint',
+    'unique',
+    'check',
+    'and',
+    'or',
+    'not',
+    'in',
+    'exists',
+    'between',
+    'like',
+    'is',
+    'as',
+    'on',
+    'into',
+    'values',
+    'set',
+    'alter',
+    'drop',
+    'create',
+    'cascade',
+    'limit',
+    'offset',
+    'union',
+    'all',
+    'distinct',
+    'having',
+    'case',
+    'when',
+    'then',
+    'else',
+    'end',
+    'order',
+    'group',
+    'by',
+    'join',
+    'left',
+    'right',
+    'inner',
+    'outer',
+    'id'
+]);
+/** Throws a 400 with a specific reason if `code` cannot safely be a table/column identifier. */ function assertValidIdentifier(code, kind) {
+    if (!_config_entity_builder_constants_js__rspack_import_2/* .ENTITY_CODE_PATTERN.test */.vs.test(code) || code.length > (/* inlined export .ENTITY_CODE_MAX_LENGTH */63)) {
+        throw new _nestjs_common__rspack_import_0.BadRequestException({
+            message: `'${code}' is not a valid ${kind} code. Use lowercase letters, digits and underscores, starting with a letter (3-60 characters).`,
+            messageKey: _config_message_keys_js__rspack_import_3/* .SCHEMA_MESSAGES.INVALID_CODE_PATTERN */.Hu.INVALID_CODE_PATTERN,
+            messageVariables: {
+                code,
+                kind
+            }
+        });
+    }
+    // An entity's events are published as entity-builder.<code>.*, so it cannot share a name with
+    // the module's own definition events.
+    const reservedForKind = kind === 'entity' && Object.values(_config_event_actions_js__rspack_import_4/* .ENTITY_BUILDER_EVENT_ENTITIES */.P).includes(code);
+    if (RESERVED_WORDS.has(code.toLowerCase()) || reservedForKind) {
+        throw new _nestjs_common__rspack_import_0.BadRequestException({
+            message: `'${code}' is a reserved word and cannot be used as a ${kind} code.`,
+            messageKey: _config_message_keys_js__rspack_import_3/* .SCHEMA_MESSAGES.RESERVED_WORD */.Hu.RESERVED_WORD,
+            messageVariables: {
+                code,
+                kind
+            }
+        });
+    }
+    if (kind === 'field' && _schema_columns_js__rspack_import_1/* .SYSTEM_COLUMN_NAMES.includes */.mq.includes(code)) {
+        throw new _nestjs_common__rspack_import_0.BadRequestException({
+            message: `'${code}' is a system column and cannot be used as a field code.`,
+            messageKey: _config_message_keys_js__rspack_import_3/* .SCHEMA_MESSAGES.SYSTEM_COLUMN_CODE */.Hu.SYSTEM_COLUMN_CODE,
+            messageVariables: {
+                code
+            }
+        });
+    }
+}
+/** Throws a 400 when a long text / JSON / multi select field is made unique or indexed. */ function assertIndexableField(field) {
+    if ((field.unique === true || field.isIndexed === true) && !(0,_schema_columns_js__rspack_import_1/* .isIndexableFieldType */.d4)(field.fieldType)) {
+        throw new _nestjs_common__rspack_import_0.BadRequestException({
+            message: `'${field.code}' is a ${field.fieldType} field, which cannot be unique or indexed.`,
+            messageKey: _config_message_keys_js__rspack_import_3/* .SCHEMA_MESSAGES.NOT_INDEXABLE */.Hu.NOT_INDEXABLE,
+            messageVariables: {
+                field: field.code,
+                fieldType: field.fieldType
+            }
+        });
+    }
+}
+
+__webpack_require__.d(__webpack_exports__, {
+  fY: () => (assertIndexableField),
+  kV: () => (assertValidIdentifier)
+}, {
+  xJ: RESERVED_WORDS
+});
+
+
+},
+921(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+/* import */ var _nestjs_common__rspack_import_0 = __webpack_require__(6157);
+/* import */ var _interfaces_reference_provider_interface_js__rspack_import_1 = __webpack_require__(2492);
+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 ReferenceScannerService {
+    flowReferences;
+    constructor(flowReferences){
+        this.flowReferences = flowReferences;
+    }
+    async forEntity(entityCode) {
+        return this.flowReferences ? this.flowReferences.findEntityReferences(entityCode) : [];
+    }
+    async forField(entityCode, fieldCode) {
+        return this.flowReferences ? this.flowReferences.findFieldReferences(entityCode, fieldCode) : [];
+    }
+    /**
+   * Rewrites every reference after a field rename. Pass the schema change's own `manager` so
+   * the rewrite is part of the same transaction. Returns how many definitions changed.
+   */ async rewriteFieldCode(entityCode, from, to, manager) {
+        return this.flowReferences ? this.flowReferences.rewriteFieldReferences(entityCode, from, to, manager) : 0;
+    }
+}
+ReferenceScannerService = _ts_decorate([
+    (0,_nestjs_common__rspack_import_0.Injectable)({
+        scope: _nestjs_common__rspack_import_0.Scope.REQUEST
+    }),
+    _ts_param(0, (0,_nestjs_common__rspack_import_0.Optional)()),
+    _ts_param(0, (0,_nestjs_common__rspack_import_0.Inject)(_interfaces_reference_provider_interface_js__rspack_import_1/* .FLOW_REFERENCE_PROVIDER */.$)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof IEntityReferenceProvider === "undefined" ? Object : IEntityReferenceProvider
+    ])
+], ReferenceScannerService);
+
+__webpack_require__.d(__webpack_exports__, {
+  t: () => (ReferenceScannerService)
+});
+
+
+},
+6605(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+/* import */ var _flusys_nestjs_shared_utils__rspack_import_0 = __webpack_require__(9216);
+/* import */ var _nestjs_common__rspack_import_1 = __webpack_require__(6157);
+/* import */ var typeorm__rspack_import_2 = __webpack_require__(7158);
+/* import */ var _config_message_keys_js__rspack_import_11 = __webpack_require__(5732);
+/* import */ var _flow_engine_flow_errors_js__rspack_import_3 = __webpack_require__(8542);
+/* import */ var _entities_entity_definition_entity_js__rspack_import_4 = __webpack_require__(3189);
+/* import */ var _entities_schema_change_log_entity_js__rspack_import_5 = __webpack_require__(875);
+/* import */ var _enums_ddl_operation_enum_js__rspack_import_12 = __webpack_require__(9949);
+/* import */ var _database_error_mapper_js__rspack_import_6 = __webpack_require__(8323);
+/* import */ var _definition_cache_service_js__rspack_import_7 = __webpack_require__(2931);
+/* import */ var _entity_builder_datasource_provider_js__rspack_import_8 = __webpack_require__(424);
+/* import */ var _schema_dialect_adapter_service_js__rspack_import_9 = __webpack_require__(7259);
+/* import */ var _schema_registry_service_js__rspack_import_10 = __webpack_require__(2134);
+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);
+    };
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+/** Codes of the entities `ids` point at: locked with a change, so none of them can be dropped meanwhile. */ async function relationTargetCodes(provider, ids) {
+    const unique = [
+        ...new Set(ids.filter((id)=>!!id))
+    ];
+    if (!unique.length) return [];
+    const targets = await (await provider.getRepository(_entities_entity_definition_entity_js__rspack_import_4/* .EntityDefinition */.f)).find({
+        select: {
+            id: true,
+            code: true
+        },
+        where: {
+            id: (0,typeorm__rspack_import_2.In)(unique)
+        }
+    });
+    return targets.map((t)=>t.code);
+}
+const hasMessage = (list, message)=>list.some((m)=>JSON.stringify(m) === JSON.stringify(message));
+const isReadOrSession = (sql)=>/^\s*(SELECT|SET|SHOW|BEGIN|COMMIT|ROLLBACK|START)/i.test(sql);
+const formatSql = (sql, params)=>params?.length ? `${sql.trim()}  -- params: ${JSON.stringify(params)}` : sql.trim();
+const format = (statement)=>formatSql(statement.query, statement.parameters);
+class SchemaChangeExecutor {
+    dataSourceProvider;
+    dialectAdapter;
+    schemaRegistry;
+    definitionCache;
+    logger = new _nestjs_common__rspack_import_1.Logger(SchemaChangeExecutor.name);
+    constructor(dataSourceProvider, dialectAdapter, schemaRegistry, definitionCache){
+        this.dataSourceProvider = dataSourceProvider;
+        this.dialectAdapter = dialectAdapter;
+        this.schemaRegistry = schemaRegistry;
+        this.definitionCache = definitionCache;
+    }
+    async simulate(target, run, impact = []) {
+        const driver = await this.dataSourceProvider.getDriver();
+        // A dedicated connection: memory mode also mutates TypeORM's cached table metadata, which
+        // must never leak into the connection that later applies the change for real.
+        const qr = await this.dataSourceProvider.getQueryRunner();
+        await qr.connect();
+        qr.enableSqlMemory();
+        const state = this.newState(target, impact);
+        try {
+            const ctx = this.buildContext(qr, driver, true, state);
+            await run(ctx);
+            if (driver === 'mysql' && state.steps.some((s)=>s.sql.length > 0)) ctx.warn((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_11/* .SCHEMA_WARNING_MESSAGES.MYSQL_NO_ROLLBACK */.Uu.MYSQL_NO_ROLLBACK));
+            return this.toPlan(target, state);
+        } finally{
+            qr.disableSqlMemory();
+            await qr.release();
+        }
+    }
+    async apply(target, run, options = {}) {
+        const plan = await this.simulate(target, run, options.impact ?? []);
+        if (plan.blockers.length > 0) {
+            throw new _nestjs_common__rspack_import_1.ConflictException({
+                message: 'This change cannot be applied.',
+                messageKey: _config_message_keys_js__rspack_import_11/* .SCHEMA_MESSAGES.BLOCKED */.Hu.BLOCKED,
+                blockers: plan.blockers,
+                plan
+            });
+        }
+        if (plan.destructive && !options.confirm) {
+            throw new _nestjs_common__rspack_import_1.BadRequestException({
+                message: 'This change loses data or information. Review the plan and resend with confirm: true.',
+                messageKey: _config_message_keys_js__rspack_import_11/* .SCHEMA_MESSAGES.CONFIRMATION_REQUIRED */.Hu.CONFIRMATION_REQUIRED,
+                plan
+            });
+        }
+        const driver = await this.dataSourceProvider.getDriver();
+        // Sorted, so two changes that lock the same entities always take them in the same order.
+        const lockKeys = [
+            ...new Set([
+                target.entityCode,
+                ...target.lockCodes ?? []
+            ])
+        ].toSorted().map((code)=>`eb_entity:${code}`);
+        const heldLocks = [];
+        const qr = await this.dataSourceProvider.getQueryRunner();
+        await qr.connect();
+        await qr.startTransaction();
+        const state = this.newState(target, options.impact ?? []);
+        let committed = false;
+        try {
+            for (const key of lockKeys){
+                await this.dialectAdapter.acquireEntityLock(qr, key, driver);
+                heldLocks.push(key);
+            }
+            const ctx = this.buildContext(qr, driver, false, state);
+            const outcome = await run(ctx);
+            if (state.blockers.length > 0) {
+                // The data changed between the dry-run and the lock - re-checked under the lock.
+                throw new _nestjs_common__rspack_import_1.ConflictException({
+                    message: 'This change can no longer be applied.',
+                    messageKey: _config_message_keys_js__rspack_import_11/* .SCHEMA_MESSAGES.NO_LONGER_APPLICABLE */.Hu.NO_LONGER_APPLICABLE,
+                    blockers: state.blockers
+                });
+            }
+            if (target.entityDefinitionId && outcome.bumpVersion !== false) {
+                const repo = qr.manager.getRepository(_entities_entity_definition_entity_js__rspack_import_4/* .EntityDefinition */.f);
+                const current = await repo.findOne({
+                    where: {
+                        id: target.entityDefinitionId
+                    }
+                });
+                if (current) await repo.update(current.id, {
+                    schemaVersion: current.schemaVersion + 1
+                });
+            }
+            await qr.manager.save(_entities_schema_change_log_entity_js__rspack_import_5/* .SchemaChangeLog */.W, qr.manager.getRepository(_entities_schema_change_log_entity_js__rspack_import_5/* .SchemaChangeLog */.W).create({
+                entityDefinitionId: outcome.entityDefinitionId ?? target.entityDefinitionId,
+                entityCode: target.entityCode,
+                operation: outcome.operation,
+                tableName: target.tableName,
+                fieldDefinitionId: outcome.fieldDefinitionId ?? null,
+                diff: outcome.diff,
+                generatedSql: state.steps.flatMap((s)=>s.sql),
+                downSql: state.downSql,
+                status: 'SUCCESS',
+                errorMessage: null,
+                performedById: target.user?.id ?? null
+            }));
+            await qr.commitTransaction();
+            committed = true;
+            const entityId = outcome.entityDefinitionId ?? target.entityDefinitionId;
+            if (entityId) this.schemaRegistry.invalidate(entityId);
+            await this.definitionCache.clearAll((0,_flusys_nestjs_shared_utils__rspack_import_0.cacheTenantId)(this.dataSourceProvider));
+            try {
+                await outcome.afterCommit?.();
+            } catch (postCommitError) {
+                // The change is already committed - reporting a failure now would be a lie.
+                this.logger.error(`Post-commit step failed after '${target.action}' on '${target.entityCode}': ${postCommitError.message}`);
+                state.warnings.push((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_11/* .SCHEMA_WARNING_MESSAGES.FOLLOW_UP_FAILED */.Uu.FOLLOW_UP_FAILED, {
+                    detail: (0,_flow_engine_flow_errors_js__rspack_import_3/* .errorRef */.O$)(postCommitError)
+                }));
+            }
+            return {
+                plan: this.toPlan(target, state),
+                outcome
+            };
+        } catch (error) {
+            if (!committed) await qr.rollbackTransaction().catch(()=>undefined);
+            const undo = !committed && driver === 'mysql' && state.undo.length > 0 ? await this.compensate(qr, target, state) : null;
+            await this.logFailure(target, error, state.steps, undo);
+            throw this.withUndo((0,_database_error_mapper_js__rspack_import_6/* .mapSchemaError */.i)(error), undo);
+        } finally{
+            for (const key of heldLocks)await this.dialectAdapter.releaseEntityLock(qr, key, driver).catch(()=>undefined);
+            await qr.release();
+        }
+    }
+    /**
+   * MySQL only: runs the reverse of every DDL statement that had run, newest first, still under
+   * the entity lock. Stops at the first undo statement that fails - running later ones against an
+   * unknown state could make it worse - and reports the rest as pending.
+   */ async compensate(qr, target, state) {
+        const statements = state.undo.toReversed().flat();
+        const pending = [];
+        for (const statement of statements){
+            if (pending.length) {
+                pending.push(statement);
+                continue;
+            }
+            try {
+                await qr.query(statement.query, statement.parameters);
+            } catch (undoError) {
+                this.logger.error(`Could not undo '${format(statement)}' after the failed '${target.action}' on '${target.entityCode}': ${undoError.message}`);
+                pending.push(statement);
+            }
+        }
+        const report = {
+            reverted: pending.length === 0,
+            pendingSql: pending.map(format),
+            dataNotReverted: state.dataSteps > 0
+        };
+        const ran = statements.length - pending.length;
+        const summary = `'${target.action}' on '${target.entityCode}' failed on MySQL after ${statements.length} DDL statement(s) had committed; ${ran} undone`;
+        if (report.reverted) this.logger.warn(`${summary}.${report.dataNotReverted ? ' Backfilled values were not undone.' : ''}`);
+        else this.logger.error(`${summary}, ${pending.length} still pending - the table and its metadata may disagree until they are run or the entity is repaired.`);
+        return report;
+    }
+    withUndo(mapped, undo) {
+        if (!undo) return mapped;
+        const status = mapped instanceof _nestjs_common__rspack_import_1.HttpException ? mapped.getStatus() : 500;
+        const original = mapped instanceof _nestjs_common__rspack_import_1.HttpException ? mapped.getResponse() : null;
+        const body = typeof original === 'object' && original !== null ? original : {};
+        if (undo.reverted && mapped instanceof _nestjs_common__rspack_import_1.HttpException) {
+            return new _nestjs_common__rspack_import_1.HttpException({
+                ...body,
+                undo
+            }, status);
+        }
+        if (undo.reverted) {
+            return new _nestjs_common__rspack_import_1.InternalServerErrorException({
+                message: 'The schema change failed and was rolled back',
+                messageKey: _config_message_keys_js__rspack_import_11/* .SCHEMA_MESSAGES.FAILED */.Hu.FAILED,
+                undo
+            });
+        }
+        return new _nestjs_common__rspack_import_1.HttpException({
+            message: 'The schema change failed and could not be fully undone.',
+            messageKey: _config_message_keys_js__rspack_import_11/* .SCHEMA_MESSAGES.FAILED_NOT_REVERTED */.Hu.FAILED_NOT_REVERTED,
+            cause: {
+                messageKey: body.messageKey,
+                details: body.details
+            },
+            undo
+        }, status);
+    }
+    /** Written on its own connection - the failed transaction's own writes were rolled back. */ async logFailure(target, error, steps = [], undo = null) {
+        try {
+            const repo = await this.dataSourceProvider.getRepository(_entities_schema_change_log_entity_js__rspack_import_5/* .SchemaChangeLog */.W);
+            const response = error instanceof _nestjs_common__rspack_import_1.HttpException ? error.getResponse() : null;
+            const messageKey = typeof response === 'object' && response !== null ? response.messageKey : undefined;
+            const message = typeof messageKey === 'string' ? messageKey : error instanceof Error ? error.message : String(error);
+            const undoNote = undo ? ` [MySQL: ${undo.reverted ? 'statements that had run were undone' : `${undo.pendingSql.length} undo statement(s) still pending`}]` : '';
+            await repo.save(repo.create({
+                entityDefinitionId: target.entityDefinitionId,
+                entityCode: target.entityCode,
+                operation: this.operationFor(target.action),
+                tableName: target.tableName,
+                fieldDefinitionId: null,
+                diff: undo ? {
+                    action: target.action,
+                    undo
+                } : {
+                    action: target.action
+                },
+                generatedSql: steps.flatMap((s)=>s.sql),
+                downSql: undo?.pendingSql.length ? undo.pendingSql : null,
+                status: 'FAILED',
+                errorMessage: `${message}${undoNote}`.slice(0, 2000),
+                performedById: target.user?.id ?? null
+            }));
+        } catch (logError) {
+            this.logger.error(`Could not record failed schema change: ${logError.message}`);
+        }
+    }
+    operationFor(action) {
+        const map = {
+            create_entity: _enums_ddl_operation_enum_js__rspack_import_12/* .DdlOperation.CREATE_TABLE */.i.CREATE_TABLE,
+            add_field: _enums_ddl_operation_enum_js__rspack_import_12/* .DdlOperation.ADD_COLUMN */.i.ADD_COLUMN,
+            update_field: _enums_ddl_operation_enum_js__rspack_import_12/* .DdlOperation.ALTER_FIELD */.i.ALTER_FIELD,
+            restore_field: _enums_ddl_operation_enum_js__rspack_import_12/* .DdlOperation.RESTORE_FIELD */.i.RESTORE_FIELD,
+            deprecate_field: _enums_ddl_operation_enum_js__rspack_import_12/* .DdlOperation.MARK_DEPRECATED */.i.MARK_DEPRECATED,
+            purge_field: _enums_ddl_operation_enum_js__rspack_import_12/* .DdlOperation.DROP_COLUMN */.i.DROP_COLUMN,
+            update_entity: _enums_ddl_operation_enum_js__rspack_import_12/* .DdlOperation.ALTER_ENTITY */.i.ALTER_ENTITY,
+            drop_entity: _enums_ddl_operation_enum_js__rspack_import_12/* .DdlOperation.DROP_TABLE */.i.DROP_TABLE,
+            repair: _enums_ddl_operation_enum_js__rspack_import_12/* .DdlOperation.REPAIR */.i.REPAIR
+        };
+        return map[action] ?? _enums_ddl_operation_enum_js__rspack_import_12/* .DdlOperation.ALTER_ENTITY */.i.ALTER_ENTITY;
+    }
+    // ── internals ─────────────────────────────────────────────────────────────────────
+    newState(target, impact) {
+        return {
+            target,
+            impact,
+            steps: [],
+            downSql: [],
+            /** Per DDL step that ran for real, its reverse statements in the order to run them. */ undo: [],
+            dataSteps: 0,
+            warnings: [],
+            blockers: [],
+            affectedRows: null,
+            destructive: false
+        };
+    }
+    toPlan(target, state) {
+        return {
+            action: target.action,
+            entityCode: target.entityCode,
+            tableName: target.tableName,
+            steps: state.steps,
+            downSql: state.downSql,
+            warnings: state.warnings,
+            blockers: state.blockers,
+            impact: state.impact,
+            affectedRows: state.affectedRows,
+            destructive: state.destructive,
+            metadataOnly: !state.steps.some((s)=>s.sql.length > 0)
+        };
+    }
+    buildContext(qr, driver, simulate, state) {
+        const escape = (name)=>qr.connection.driver.escape(name);
+        const recordUndo = (reverse)=>{
+            if (!reverse.length) return;
+            state.undo.push(reverse);
+            state.downSql.unshift(...reverse.map(format));
+        };
+        return {
+            qr,
+            driver,
+            get blocked () {
+                return state.blockers.length > 0;
+            },
+            q: escape,
+            ddl: async (description, fn)=>{
+                // TypeORM records every schema statement and its reverse in the SQL memory in both modes;
+                // only memory mode skips running them.
+                qr.clearSqlMemory();
+                if (simulate) {
+                    await fn();
+                    const memory = qr.getMemorySql();
+                    state.steps.push({
+                        description,
+                        sql: memory.upQueries.map(format)
+                    });
+                    state.downSql.unshift(...memory.downQueries.map(format).toReversed());
+                    qr.clearSqlMemory();
+                    return;
+                }
+                const captured = [];
+                const original = qr.query.bind(qr);
+                let failed = false;
+                qr.query = (sql, params, ...rest)=>{
+                    if (!isReadOrSession(sql)) captured.push(formatSql(sql, params));
+                    return original(sql, params, ...rest);
+                };
+                try {
+                    await fn();
+                } catch (error) {
+                    failed = true;
+                    throw error;
+                } finally{
+                    qr.query = original;
+                    const down = qr.getMemorySql().downQueries.map((q)=>({
+                            query: q.query,
+                            parameters: q.parameters
+                        }));
+                    qr.clearSqlMemory();
+                    // TypeORM pairs each statement with its reverse; on failure the last captured one is the one that failed.
+                    const ran = failed ? Math.max(captured.length - 1, 0) : down.length;
+                    state.steps.push({
+                        description,
+                        sql: captured
+                    });
+                    recordUndo(down.slice(0, ran).toReversed());
+                }
+            },
+            rawDdl: async (description, sql, downSql = [])=>{
+                if (simulate) {
+                    state.steps.push({
+                        description,
+                        sql
+                    });
+                    state.downSql.unshift(...downSql.toReversed());
+                    return;
+                }
+                let ran = 0;
+                try {
+                    for (const statement of sql){
+                        await qr.query(statement);
+                        ran += 1;
+                    }
+                } finally{
+                    state.steps.push({
+                        description,
+                        sql: sql.slice(0, ran + (ran < sql.length ? 1 : 0))
+                    });
+                    recordUndo(downSql.slice(0, ran).toReversed().map((query)=>({
+                            query
+                        })));
+                }
+            },
+            data: async (description, sqlPreview, fn)=>{
+                if (!simulate) {
+                    await fn();
+                    state.dataSteps += 1;
+                }
+                state.steps.push({
+                    description,
+                    sql: [
+                        sqlPreview
+                    ]
+                });
+            },
+            metadata: async (fn)=>{
+                if (!simulate) await fn();
+            },
+            warn: (message)=>{
+                if (!hasMessage(state.warnings, message)) state.warnings.push(message);
+            },
+            block: (message)=>{
+                if (!hasMessage(state.blockers, message)) state.blockers.push(message);
+            },
+            setAffectedRows: (count)=>{
+                state.affectedRows = count;
+            },
+            markDestructive: ()=>{
+                state.destructive = true;
+            }
+        };
+    }
+}
+SchemaChangeExecutor = _ts_decorate([
+    (0,_nestjs_common__rspack_import_1.Injectable)({
+        scope: _nestjs_common__rspack_import_1.Scope.REQUEST
+    }),
+    _ts_param(0, (0,_nestjs_common__rspack_import_1.Inject)(_entity_builder_datasource_provider_js__rspack_import_8/* .EntityBuilderDataSourceProvider */.D)),
+    _ts_param(1, (0,_nestjs_common__rspack_import_1.Inject)(_schema_dialect_adapter_service_js__rspack_import_9/* .SchemaDialectAdapterService */.I)),
+    _ts_param(2, (0,_nestjs_common__rspack_import_1.Inject)(_schema_registry_service_js__rspack_import_10/* .SchemaRegistryService */.C)),
+    _ts_param(3, (0,_nestjs_common__rspack_import_1.Inject)(_definition_cache_service_js__rspack_import_7/* .DefinitionCacheService */.V)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _entity_builder_datasource_provider_js__rspack_import_8/* .EntityBuilderDataSourceProvider */.D === "undefined" ? Object : _entity_builder_datasource_provider_js__rspack_import_8/* .EntityBuilderDataSourceProvider */.D,
+        typeof _schema_dialect_adapter_service_js__rspack_import_9/* .SchemaDialectAdapterService */.I === "undefined" ? Object : _schema_dialect_adapter_service_js__rspack_import_9/* .SchemaDialectAdapterService */.I,
+        typeof _schema_registry_service_js__rspack_import_10/* .SchemaRegistryService */.C === "undefined" ? Object : _schema_registry_service_js__rspack_import_10/* .SchemaRegistryService */.C,
+        typeof _definition_cache_service_js__rspack_import_7/* .DefinitionCacheService */.V === "undefined" ? Object : _definition_cache_service_js__rspack_import_7/* .DefinitionCacheService */.V
+    ])
+], SchemaChangeExecutor);
+
+__webpack_require__.d(__webpack_exports__, {
+  T: () => (SchemaChangeExecutor),
+  e: () => (relationTargetCodes)
+});
+
+
+},
+7827(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+/** `"Name", "Other"` - the impacted flow names; the translated message supplies the word "flows". */ const describeImpact = (impact)=>impact.map((i)=>`"${i.name}"`).join(', ');
+
+__webpack_require__.d(__webpack_exports__, {
+}, {
+  a: describeImpact
+});
+
+
+},
+3606(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+/* import */ var _flusys_nestjs_shared_classes__rspack_import_0 = __webpack_require__(6937);
+/* import */ var _flusys_nestjs_shared_utils__rspack_import_1 = __webpack_require__(9216);
+/* import */ var _nestjs_common__rspack_import_2 = __webpack_require__(6157);
+/* import */ var class_transformer__rspack_import_3 = __webpack_require__(5812);
+/* import */ var class_validator__rspack_import_4 = __webpack_require__(5421);
+/* import */ var typeorm__rspack_import_5 = __webpack_require__(7158);
+/* import */ var _config_message_keys_js__rspack_import_19 = __webpack_require__(5732);
+/* import */ var _dtos_schema_change_dto_js__rspack_import_6 = __webpack_require__(4945);
+/* import */ var _entities_entity_definition_entity_js__rspack_import_7 = __webpack_require__(3189);
+/* import */ var _entities_field_definition_entity_js__rspack_import_8 = __webpack_require__(2206);
+/* import */ var _entities_schema_change_log_entity_js__rspack_import_9 = __webpack_require__(875);
+/* import */ var _enums_ddl_operation_enum_js__rspack_import_21 = __webpack_require__(9949);
+/* import */ var _enums_entity_status_enum_js__rspack_import_23 = __webpack_require__(1313);
+/* import */ var _enums_field_type_enum_js__rspack_import_20 = __webpack_require__(9614);
+/* import */ var _entity_builder_datasource_provider_js__rspack_import_10 = __webpack_require__(424);
+/* import */ var _entity_permission_service_js__rspack_import_11 = __webpack_require__(1462);
+/* import */ var _field_value_validator_js__rspack_import_12 = __webpack_require__(3525);
+/* import */ var _field_type_conversion_js__rspack_import_13 = __webpack_require__(4984);
+/* import */ var _identifier_rules_js__rspack_import_14 = __webpack_require__(413);
+/* import */ var _reference_scanner_service_js__rspack_import_15 = __webpack_require__(921);
+/* import */ var _schema_change_executor_service_js__rspack_import_16 = __webpack_require__(6605);
+/* import */ var _schema_change_types_js__rspack_import_22 = __webpack_require__(7827);
+/* import */ var _schema_columns_js__rspack_import_17 = __webpack_require__(5313);
+/* import */ var _schema_dialect_adapter_service_js__rspack_import_18 = __webpack_require__(7259);
+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 entityNotFound = (id)=>new _nestjs_common__rspack_import_2.NotFoundException({
+        message: `Entity definition '${id}' not found.`,
+        messageKey: _config_message_keys_js__rspack_import_19/* .ENTITY_DEFINITION_MESSAGES.NOT_FOUND */.pL.NOT_FOUND,
+        messageVariables: {
+            id
+        }
+    });
+const fieldNotFound = (id)=>new _nestjs_common__rspack_import_2.NotFoundException({
+        message: `Field definition '${id}' not found.`,
+        messageKey: _config_message_keys_js__rspack_import_19/* .FIELD_DEFINITION_MESSAGES.NOT_FOUND */.oc.NOT_FOUND,
+        messageVariables: {
+            id
+        }
+    });
+const DESTRUCTIVE_ACTIONS = [
+    _dtos_schema_change_dto_js__rspack_import_6/* .SchemaChangeAction.DROP_ENTITY */.M3.DROP_ENTITY,
+    _dtos_schema_change_dto_js__rspack_import_6/* .SchemaChangeAction.PURGE_FIELD */.M3.PURGE_FIELD
+];
+const isDestructiveSchemaAction = (action)=>DESTRUCTIVE_ACTIONS.includes(action);
+const fieldLike = (field)=>({
+        code: field.code,
+        label: field.label ?? field.code,
+        fieldType: field.fieldType,
+        nullable: true,
+        defaultValue: null,
+        selectOptions: field.selectOptions ?? null,
+        validationRules: field.validationRules ?? null
+    });
+class SchemaEvolutionService {
+    dataSourceProvider;
+    adapter;
+    executor;
+    references;
+    permissions;
+    constructor(dataSourceProvider, adapter, executor, references, permissions){
+        this.dataSourceProvider = dataSourceProvider;
+        this.adapter = adapter;
+        this.executor = executor;
+        this.references = references;
+        this.permissions = permissions;
+    }
+    // ── public API ──────────────────────────────────────────────────────────────────────
+    async plan(request, user) {
+        const prepared = await this.prepare(request, user);
+        return this.executor.simulate(prepared.target, prepared.run, prepared.impact);
+    }
+    async apply(request, user) {
+        const prepared = await this.prepare(request, user);
+        const { plan, outcome } = await this.executor.apply(prepared.target, prepared.run, {
+            confirm: request.confirm === true,
+            impact: prepared.impact
+        });
+        return {
+            ...plan,
+            result: outcome.diff
+        };
+    }
+    /** Compares the metadata with the real table and reports every difference. */ async inspect(entityDefinitionId) {
+        const { definition, fields } = await this.loadEntity(entityDefinitionId);
+        const driver = await this.dataSourceProvider.getDriver();
+        const qr = await this.dataSourceProvider.getQueryRunner();
+        await qr.connect();
+        try {
+            const table = await qr.getTable(definition.tableName);
+            const findings = this.diff(definition, fields, table ?? undefined, driver);
+            let rowCount = null;
+            if (table) {
+                const rows = await qr.query(`SELECT COUNT(*) AS c FROM ${qr.connection.driver.escape(definition.tableName)}`);
+                rowCount = Number(rows[0]?.c ?? 0);
+            }
+            return {
+                entityCode: definition.code,
+                tableName: definition.tableName,
+                healthy: findings.every((f)=>f.severity !== 'error'),
+                rowCount,
+                findings
+            };
+        } finally{
+            await qr.release();
+        }
+    }
+    /** Newest first. Includes failed attempts, with the SQL that was about to run. */ async history(entityDefinitionId, limit = 50) {
+        const repo = await this.dataSourceProvider.getRepository(_entities_schema_change_log_entity_js__rspack_import_9/* .SchemaChangeLog */.W);
+        return repo.find({
+            select: {
+                id: true,
+                operation: true,
+                status: true,
+                tableName: true,
+                generatedSql: true,
+                downSql: true,
+                errorMessage: true,
+                diff: true,
+                createdAt: true,
+                performedById: true
+            },
+            where: {
+                entityDefinitionId
+            },
+            order: {
+                createdAt: 'DESC'
+            },
+            take: Math.min(Math.max(limit, 1), 200)
+        });
+    }
+    // ── loading ─────────────────────────────────────────────────────────────────────────
+    async loadEntity(entityDefinitionId) {
+        if (!entityDefinitionId) {
+            throw new _nestjs_common__rspack_import_2.BadRequestException({
+                message: 'entityDefinitionId is required for this action.',
+                messageKey: _config_message_keys_js__rspack_import_19/* .ENTITY_DEFINITION_MESSAGES.ID_REQUIRED */.pL.ID_REQUIRED
+            });
+        }
+        return this.definitions((entity)=>this.dataSourceProvider.getRepository(entity), entityDefinitionId);
+    }
+    async loadField(fieldDefinitionId) {
+        if (!fieldDefinitionId) {
+            throw new _nestjs_common__rspack_import_2.BadRequestException({
+                message: 'fieldDefinitionId is required for this action.',
+                messageKey: _config_message_keys_js__rspack_import_19/* .FIELD_DEFINITION_MESSAGES.ID_REQUIRED */.oc.ID_REQUIRED
+            });
+        }
+        const field = await (await this.dataSourceProvider.getRepository(_entities_field_definition_entity_js__rspack_import_8/* .FieldDefinition */.c)).findOne({
+            where: {
+                id: fieldDefinitionId
+            }
+        });
+        if (!field) throw fieldNotFound(fieldDefinitionId);
+        return {
+            ...await this.loadEntity(field.entityDefinitionId),
+            field
+        };
+    }
+    async definitions(repositoryOf, entityDefinitionId, fieldDefinitionId) {
+        const definition = await (await repositoryOf(_entities_entity_definition_entity_js__rspack_import_7/* .EntityDefinition */.f)).findOne({
+            where: {
+                id: entityDefinitionId
+            }
+        });
+        if (!definition) throw entityNotFound(entityDefinitionId);
+        const fields = await (await repositoryOf(_entities_field_definition_entity_js__rspack_import_8/* .FieldDefinition */.c)).find({
+            where: {
+                entityDefinitionId
+            },
+            order: {
+                order: 'ASC'
+            }
+        });
+        const field = fieldDefinitionId ? fields.find((f)=>f.id === fieldDefinitionId) : undefined;
+        if (fieldDefinitionId && !field) throw fieldNotFound(fieldDefinitionId);
+        return {
+            definition,
+            fields,
+            field
+        };
+    }
+    rejectUnknownKeys(changes, allowed, what) {
+        const unknown = Object.keys(changes).filter((k)=>!allowed.includes(k));
+        if (unknown.length) {
+            throw new _nestjs_common__rspack_import_2.BadRequestException({
+                message: `Cannot change ${what} property: ${unknown.join(', ')}. Allowed: ${allowed.join(', ')}.`,
+                messageKey: _config_message_keys_js__rspack_import_19/* .SCHEMA_MESSAGES.UNKNOWN_CHANGE_PROPERTY */.Hu.UNKNOWN_CHANGE_PROPERTY,
+                messageVariables: {
+                    what,
+                    properties: unknown.join(', '),
+                    allowed: allowed.join(', ')
+                }
+            });
+        }
+    }
+    validateChanges(dto, changes) {
+        const errors = (0,class_validator__rspack_import_4.validateSync)((0,class_transformer__rspack_import_3.plainToInstance)(dto, changes), {
+            forbidUnknownValues: false
+        });
+        if (!errors.length) return;
+        const properties = errors.map((e)=>e.property);
+        throw new _nestjs_common__rspack_import_2.BadRequestException({
+            message: `Invalid value for ${properties.map((p)=>`'${p}'`).join(', ')}.`,
+            messageKey: _config_message_keys_js__rspack_import_19/* .SCHEMA_MESSAGES.INVALID_CHANGE_VALUE */.Hu.INVALID_CHANGE_VALUE,
+            messageVariables: {
+                property: properties.join(', ')
+            },
+            errors: properties.map((property)=>({
+                    field: property,
+                    messageKey: _config_message_keys_js__rspack_import_19/* .SCHEMA_MESSAGES.INVALID_CHANGE_VALUE */.Hu.INVALID_CHANGE_VALUE,
+                    messageVariables: {
+                        property
+                    }
+                }))
+        });
+    }
+    async current(ctx, request, entityDefinitionId, fieldDefinitionId) {
+        const found = await this.definitions((entity)=>ctx.qr.manager.getRepository(entity), entityDefinitionId, fieldDefinitionId);
+        if (request.expectedUpdatedAt) {
+            await this.assertNotStale(ctx, fieldDefinitionId ? _entities_field_definition_entity_js__rspack_import_8/* .FieldDefinition */.c : _entities_entity_definition_entity_js__rspack_import_7/* .EntityDefinition */.f, fieldDefinitionId ?? entityDefinitionId, request.expectedUpdatedAt);
+        }
+        return found;
+    }
+    async assertNotStale(ctx, entity, id, expected) {
+        const row = await ctx.qr.manager.getRepository(entity).findOne({
+            select: {
+                id: true,
+                updatedAt: true
+            },
+            where: {
+                id
+            }
+        });
+        const updatedAt = row?.updatedAt ? new Date(row.updatedAt) : null;
+        if (updatedAt && updatedAt.getTime() !== new Date(expected).getTime()) {
+            throw new _nestjs_common__rspack_import_2.ConflictException({
+                message: 'Someone else changed this definition since you opened it. Reload it and make your change again.',
+                messageKey: _config_message_keys_js__rspack_import_19/* .SCHEMA_MESSAGES.STALE_DEFINITION */.Hu.STALE_DEFINITION,
+                messageVariables: {
+                    updatedAt: updatedAt.toISOString()
+                }
+            });
+        }
+    }
+    /** The field was renamed (or deprecated) by a change that committed after this request was checked. */ changedUnderneath(ctx, before, now) {
+        if (now.code === before.code && !!now.deprecatedAt === !!before.deprecatedAt) return false;
+        ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_BLOCKER_MESSAGES.DEFINITION_CHANGED */.M3.DEFINITION_CHANGED));
+        return true;
+    }
+    // ── dispatch ────────────────────────────────────────────────────────────────────────
+    async prepare(request, user) {
+        switch(request.action){
+            case _dtos_schema_change_dto_js__rspack_import_6/* .SchemaChangeAction.ADD_FIELD */.M3.ADD_FIELD:
+                return this.prepareAddField(request, user);
+            case _dtos_schema_change_dto_js__rspack_import_6/* .SchemaChangeAction.UPDATE_FIELD */.M3.UPDATE_FIELD:
+                return this.prepareUpdateField(request, user);
+            case _dtos_schema_change_dto_js__rspack_import_6/* .SchemaChangeAction.DEPRECATE_FIELD */.M3.DEPRECATE_FIELD:
+                return this.prepareDeprecateField(request, user);
+            case _dtos_schema_change_dto_js__rspack_import_6/* .SchemaChangeAction.RESTORE_FIELD */.M3.RESTORE_FIELD:
+                return this.prepareRestoreField(request, user);
+            case _dtos_schema_change_dto_js__rspack_import_6/* .SchemaChangeAction.PURGE_FIELD */.M3.PURGE_FIELD:
+                return this.preparePurgeField(request, user);
+            case _dtos_schema_change_dto_js__rspack_import_6/* .SchemaChangeAction.UPDATE_ENTITY */.M3.UPDATE_ENTITY:
+                return this.prepareUpdateEntity(request, user);
+            case _dtos_schema_change_dto_js__rspack_import_6/* .SchemaChangeAction.DROP_ENTITY */.M3.DROP_ENTITY:
+                return this.prepareDropEntity(request, user);
+            case _dtos_schema_change_dto_js__rspack_import_6/* .SchemaChangeAction.REPAIR */.M3.REPAIR:
+                return this.prepareRepair(request, user);
+        }
+    }
+    target(action, definition, user, lockCodes = []) {
+        return {
+            action,
+            entityDefinitionId: definition.id,
+            entityCode: definition.code,
+            tableName: definition.tableName,
+            user,
+            lockCodes
+        };
+    }
+    // ── small SQL helpers (identifiers come from validated metadata and are escaped) ────
+    // No placeholder rewriting here: prechecks embed regexes containing '?', which buildQuery would corrupt.
+    async scalar(ctx, sql, params) {
+        const rows = await ctx.qr.query(sql, params);
+        return Number(Object.values(rows[0] ?? {
+            c: 0
+        })[0]);
+    }
+    /** A count that only feeds a warning: a failure reads as 0 and, thanks to the savepoint, leaves the change's transaction usable. */ advisoryScalar(ctx, sql, params) {
+        return (0,_flusys_nestjs_shared_utils__rspack_import_1.withSavepoint)(ctx.qr, ()=>this.scalar(ctx, sql, params)).catch(()=>0);
+    }
+    paramValue(fieldType, value) {
+        return fieldType === _enums_field_type_enum_js__rspack_import_20/* .FieldType.JSON */.P.JSON || fieldType === _enums_field_type_enum_js__rspack_import_20/* .FieldType.MULTI_SELECT */.P.MULTI_SELECT ? JSON.stringify(value) : value;
+    }
+    notNullSql(ctx, table, column, fieldType, notNull) {
+        if (ctx.driver === 'postgres') {
+            return `ALTER TABLE ${ctx.q(table)} ALTER COLUMN ${ctx.q(column)} ${notNull ? 'SET' : 'DROP'} NOT NULL`;
+        }
+        return `ALTER TABLE ${ctx.q(table)} MODIFY ${ctx.q(column)} ${(0,_schema_columns_js__rspack_import_17/* .sqlTypeFor */.cg)(fieldType, ctx.driver, this.adapter)} ${notNull ? 'NOT NULL' : 'NULL'}`;
+    }
+    /** Makes a column NOT NULL (or nullable again), with the reverse statement for the plan. */ setRequired(ctx, table, column, fieldType, required, step = required ? _config_message_keys_js__rspack_import_19/* .SCHEMA_STEP_MESSAGES.MAKE_REQUIRED */.EQ.MAKE_REQUIRED : _config_message_keys_js__rspack_import_19/* .SCHEMA_STEP_MESSAGES.MAKE_OPTIONAL */.EQ.MAKE_OPTIONAL) {
+        return ctx.rawDdl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(step, {
+            column
+        }), [
+            this.notNullSql(ctx, table, column, fieldType, required)
+        ], [
+            this.notNullSql(ctx, table, column, fieldType, !required)
+        ]);
+    }
+    checkValue(field, value) {
+        const { errors } = (0,_field_value_validator_js__rspack_import_12/* .validateRecord */.e)([
+            fieldLike(field)
+        ], {
+            [field.code]: value
+        }, 'insert');
+        return errors[0] ? (0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(errors[0].messageKey, errors[0].messageVariables) : null;
+    }
+    async requireTable(ctx, tableName) {
+        const table = await ctx.qr.getTable(tableName);
+        if (!table) {
+            ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_BLOCKER_MESSAGES.TABLE_MISSING */.M3.TABLE_MISSING, {
+                table: tableName
+            }));
+        }
+        return table ?? undefined;
+    }
+    /** How many values a unique constraint on `code` would clash on. */ countDuplicates(ctx, table, code) {
+        const key = ctx.q(code);
+        return this.scalar(ctx, `SELECT COUNT(*) AS c FROM (SELECT ${key} FROM ${ctx.q(table)} WHERE ${key} IS NOT NULL GROUP BY ${key} HAVING COUNT(*) > 1) d`);
+    }
+    async dropUniques(ctx, table, code) {
+        const drop = (columnNames)=>(0,_schema_columns_js__rspack_import_17/* .sameColumns */.G7)(columnNames, [
+                code
+            ]);
+        for (const uq of table.uniques.filter((u)=>drop(u.columnNames)))await ctx.qr.dropUniqueConstraint(table, uq);
+        for (const idx of table.indices.filter((i)=>i.isUnique && drop(i.columnNames)))await ctx.qr.dropIndex(table, idx);
+    }
+    hasUnique(table, code) {
+        if (table.uniques.some((u)=>(0,_schema_columns_js__rspack_import_17/* .sameColumns */.G7)(u.columnNames, [
+                code
+            ]))) return true;
+        if (table.indices.some((i)=>i.isUnique && (0,_schema_columns_js__rspack_import_17/* .sameColumns */.G7)(i.columnNames, [
+                code
+            ]))) return true;
+        return !!table.findColumnByName(code)?.isUnique;
+    }
+    indexOn(table, column, unique) {
+        return table.indices.filter((i)=>i.columnNames.length === 1 && i.columnNames[0] === column && i.isUnique === unique);
+    }
+    // ── add_field ───────────────────────────────────────────────────────────────────────
+    async prepareAddField(request, user) {
+        const { definition: loaded } = await this.loadEntity(request.entityDefinitionId);
+        const spec = request.field;
+        if (!spec) {
+            throw new _nestjs_common__rspack_import_2.BadRequestException({
+                message: "add_field needs a 'field' definition.",
+                messageKey: _config_message_keys_js__rspack_import_19/* .FIELD_DEFINITION_MESSAGES.DEFINITION_REQUIRED */.oc.DEFINITION_REQUIRED
+            });
+        }
+        (0,_identifier_rules_js__rspack_import_14/* .assertValidIdentifier */.kV)(spec.code, 'field');
+        (0,_identifier_rules_js__rspack_import_14/* .assertIndexableField */.fY)(spec);
+        const lockCodes = await (0,_schema_change_executor_service_js__rspack_import_16/* .relationTargetCodes */.e)(this.dataSourceProvider, [
+            spec.relationTargetEntityId
+        ]);
+        const run = async (ctx)=>{
+            const { definition, fields } = await this.current(ctx, request, loaded.id);
+            const existing = fields.find((f)=>f.code === spec.code);
+            if (existing) {
+                ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(existing.deprecatedAt ? _config_message_keys_js__rspack_import_19/* .SCHEMA_BLOCKER_MESSAGES.FIELD_EXISTS_DEPRECATED */.M3.FIELD_EXISTS_DEPRECATED : _config_message_keys_js__rspack_import_19/* .SCHEMA_BLOCKER_MESSAGES.FIELD_EXISTS */.M3.FIELD_EXISTS, {
+                    code: spec.code
+                }));
+            }
+            const nullable = spec.nullable ?? true;
+            const unique = spec.unique ?? false;
+            const dbType = this.adapter.mapFieldType(spec.fieldType, ctx.driver);
+            const isRelation = spec.fieldType === _enums_field_type_enum_js__rspack_import_20/* .FieldType.RELATION */.P.RELATION;
+            if (isRelation && !spec.relationTargetEntityId) {
+                ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_BLOCKER_MESSAGES.RELATION_TARGET_REQUIRED */.M3.RELATION_TARGET_REQUIRED, {
+                    field: spec.code
+                }));
+            } else if (isRelation) {
+                const target = await ctx.qr.manager.getRepository(_entities_entity_definition_entity_js__rspack_import_7/* .EntityDefinition */.f).findOne({
+                    where: {
+                        id: spec.relationTargetEntityId
+                    }
+                });
+                if (!target) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_BLOCKER_MESSAGES.RELATION_TARGET_MISSING */.M3.RELATION_TARGET_MISSING));
+            }
+            if ((spec.fieldType === _enums_field_type_enum_js__rspack_import_20/* .FieldType.SINGLE_SELECT */.P.SINGLE_SELECT || spec.fieldType === _enums_field_type_enum_js__rspack_import_20/* .FieldType.MULTI_SELECT */.P.MULTI_SELECT) && !spec.selectOptions?.length) {
+                ctx.warn((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_WARNING_MESSAGES.NO_SELECT_OPTIONS_YET */.Uu.NO_SELECT_OPTIONS_YET));
+            }
+            if (spec.defaultValue !== undefined && spec.defaultValue !== null) {
+                const problem = this.checkValue({
+                    ...spec,
+                    code: spec.code,
+                    fieldType: spec.fieldType
+                }, spec.defaultValue);
+                if (problem) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_BLOCKER_MESSAGES.DEFAULT_INVALID */.M3.DEFAULT_INVALID, {
+                    problem
+                }));
+            }
+            const table = await this.requireTable(ctx, definition.tableName);
+            const rows = table ? await this.scalar(ctx, `SELECT COUNT(*) AS c FROM ${ctx.q(definition.tableName)}`) : 0;
+            const backfill = request.backfillValue ?? spec.defaultValue ?? null;
+            if (!nullable && rows > 0) {
+                if (backfill === null) {
+                    ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_BLOCKER_MESSAGES.REQUIRED_NEEDS_VALUE */.M3.REQUIRED_NEEDS_VALUE, {
+                        count: rows
+                    }));
+                } else {
+                    const problem = this.checkValue({
+                        ...spec,
+                        code: spec.code,
+                        fieldType: spec.fieldType
+                    }, backfill);
+                    if (problem) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_BLOCKER_MESSAGES.BACKFILL_INVALID */.M3.BACKFILL_INVALID, {
+                        problem
+                    }));
+                }
+            }
+            // Only a required field is backfilled; every existing row gets the same value, so two rows or more would clash.
+            if (unique && !nullable && backfill !== null && rows > 1) {
+                ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_BLOCKER_MESSAGES.UNIQUE_BACKFILL_CONFLICT */.M3.UNIQUE_BACKFILL_CONFLICT));
+            }
+            if (ctx.blocked || !table) {
+                return {
+                    operation: _enums_ddl_operation_enum_js__rspack_import_21/* .DdlOperation.ADD_COLUMN */.i.ADD_COLUMN,
+                    diff: {}
+                };
+            }
+            const column = (0,_schema_columns_js__rspack_import_17/* .buildFieldColumn */.fu)({
+                code: spec.code,
+                fieldType: spec.fieldType,
+                dbType,
+                nullable,
+                unique
+            }, ctx.driver, this.adapter, {
+                enforceNotNull: false,
+                withUnique: false
+            });
+            await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_STEP_MESSAGES.ADD_COLUMN */.EQ.ADD_COLUMN, {
+                column: spec.code
+            }), async ()=>{
+                await ctx.qr.addColumn(table, column);
+            });
+            if (!nullable && rows > 0) {
+                await ctx.data((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_STEP_MESSAGES.BACKFILL_EXISTING */.EQ.BACKFILL_EXISTING, {
+                    count: rows
+                }), `UPDATE ${ctx.q(definition.tableName)} SET ${ctx.q(spec.code)} = ${this.adapter.sqlLiteral(this.paramValue(spec.fieldType, backfill), ctx.driver)}`, async ()=>{
+                    await ctx.qr.query((0,_flusys_nestjs_shared_classes__rspack_import_0.buildQuery)(`UPDATE ${ctx.q(definition.tableName)} SET ${ctx.q(spec.code)} = ?`, ctx.driver), [
+                        this.paramValue(spec.fieldType, backfill)
+                    ]);
+                });
+            }
+            if (!nullable) {
+                await this.setRequired(ctx, definition.tableName, spec.code, spec.fieldType, true);
+            }
+            if (unique) {
+                await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_STEP_MESSAGES.ADD_UNIQUE */.EQ.ADD_UNIQUE, {
+                    column: spec.code
+                }), async ()=>{
+                    await (0,_schema_columns_js__rspack_import_17/* .addUnique */.$6)(ctx.qr, table, spec.code, ctx.driver, this.adapter);
+                });
+            }
+            if (spec.isIndexed && !unique) {
+                await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_STEP_MESSAGES.ADD_INDEX */.EQ.ADD_INDEX, {
+                    column: spec.code
+                }), async ()=>{
+                    await ctx.qr.createIndex(table, (0,_schema_columns_js__rspack_import_17/* .plainIndex */.v7)(definition.tableName, spec.code, ctx.driver, this.adapter));
+                });
+            }
+            let fieldId = null;
+            await ctx.metadata(async ()=>{
+                const repo = ctx.qr.manager.getRepository(_entities_field_definition_entity_js__rspack_import_8/* .FieldDefinition */.c);
+                const saved = await repo.save(repo.create({
+                    entityDefinitionId: definition.id,
+                    code: spec.code,
+                    label: spec.label,
+                    fieldType: spec.fieldType,
+                    dbType,
+                    nullable,
+                    unique,
+                    isIndexed: spec.isIndexed ?? false,
+                    defaultValue: spec.defaultValue ?? null,
+                    validationRules: spec.validationRules ?? null,
+                    selectOptions: spec.selectOptions ?? null,
+                    relationTargetEntityId: isRelation ? spec.relationTargetEntityId : null,
+                    order: spec.order ?? Math.max(-1, ...fields.map((f)=>f.order)) + 1,
+                    uiConfig: spec.uiConfig ?? null,
+                    isSearchable: spec.isSearchable ?? false,
+                    isSystemField: false,
+                    deprecatedAt: null
+                }));
+                fieldId = saved.id;
+            });
+            return {
+                operation: _enums_ddl_operation_enum_js__rspack_import_21/* .DdlOperation.ADD_COLUMN */.i.ADD_COLUMN,
+                fieldDefinitionId: fieldId,
+                diff: {
+                    field: {
+                        code: spec.code,
+                        fieldType: spec.fieldType,
+                        nullable,
+                        unique
+                    },
+                    backfilledRows: !nullable ? rows : 0
+                }
+            };
+        };
+        return {
+            target: this.target('add_field', loaded, user, lockCodes),
+            run,
+            impact: []
+        };
+    }
+    // ── update_field ────────────────────────────────────────────────────────────────────
+    async prepareUpdateField(request, user) {
+        const { field: loadedField, definition: loaded } = await this.loadField(request.fieldDefinitionId);
+        const changes = request.changes ?? {};
+        this.rejectUnknownKeys(changes, _dtos_schema_change_dto_js__rspack_import_6/* .FIELD_CHANGE_KEYS */.bD, 'field');
+        this.validateChanges(_dtos_schema_change_dto_js__rspack_import_6/* .FieldChangesDto */.Pr, changes);
+        if (loadedField.deprecatedAt) {
+            throw new _nestjs_common__rspack_import_2.BadRequestException({
+                message: 'A deprecated field cannot be changed. Restore it first.',
+                messageKey: _config_message_keys_js__rspack_import_19/* .FIELD_DEFINITION_MESSAGES.DEPRECATED_LOCKED */.oc.DEPRECATED_LOCKED
+            });
+        }
+        const newCode = typeof changes.code === 'string' && changes.code !== loadedField.code ? changes.code : null;
+        if (newCode) (0,_identifier_rules_js__rspack_import_14/* .assertValidIdentifier */.kV)(newCode, 'field');
+        const structuralKeys = (field)=>[
+                'fieldType',
+                'nullable',
+                'unique',
+                'isIndexed'
+            ].filter((k)=>k in changes && changes[k] !== field[k]);
+        const requested = structuralKeys(loadedField);
+        if (newCode && requested.length) {
+            throw new _nestjs_common__rspack_import_2.BadRequestException({
+                message: `Rename '${loadedField.code}' in its own change - it cannot be combined with: ${requested.join(', ')}.`,
+                messageKey: _config_message_keys_js__rspack_import_19/* .FIELD_DEFINITION_MESSAGES.RENAME_ALONE */.oc.RENAME_ALONE,
+                messageVariables: {
+                    field: loadedField.code,
+                    changes: requested.join(', ')
+                }
+            });
+        }
+        if ([
+            'fieldType',
+            'unique',
+            'isIndexed'
+        ].some((k)=>k in changes)) {
+            (0,_identifier_rules_js__rspack_import_14/* .assertIndexableField */.fY)({
+                ...loadedField,
+                ...changes,
+                code: loadedField.code
+            });
+        }
+        const targetType = changes.fieldType ?? loadedField.fieldType;
+        const newTargetId = typeof changes.relationTargetEntityId === 'string' ? changes.relationTargetEntityId : null;
+        if (newTargetId && targetType !== _enums_field_type_enum_js__rspack_import_20/* .FieldType.RELATION */.P.RELATION) {
+            throw new _nestjs_common__rspack_import_2.BadRequestException({
+                message: 'relationTargetEntityId can only be set on a RELATION field.',
+                messageKey: _config_message_keys_js__rspack_import_19/* .SCHEMA_MESSAGES.INVALID_CHANGE_VALUE */.Hu.INVALID_CHANGE_VALUE,
+                messageVariables: {
+                    property: 'relationTargetEntityId'
+                }
+            });
+        }
+        const lockCodes = await (0,_schema_change_executor_service_js__rspack_import_16/* .relationTargetCodes */.e)(this.dataSourceProvider, [
+            newTargetId
+        ]);
+        const impact = newCode || changes.fieldType !== undefined ? await this.references.forField(loaded.code, loadedField.code) : [];
+        const run = async (ctx)=>{
+            const { definition, fields, field } = await this.current(ctx, request, loaded.id, loadedField.id);
+            if (this.changedUnderneath(ctx, loadedField, field)) {
+                return {
+                    operation: _enums_ddl_operation_enum_js__rspack_import_21/* .DdlOperation.ALTER_FIELD */.i.ALTER_FIELD,
+                    fieldDefinitionId: field.id,
+                    diff: {}
+                };
+            }
+            const structural = structuralKeys(field);
+            const merged = {
+                ...field,
+                ...changes
+            };
+            const patch = {};
+            const table = structural.length || newCode ? await this.requireTable(ctx, definition.tableName) : undefined;
+            const column = table?.findColumnByName(field.code);
+            if ((structural.length || newCode) && table && !column) {
+                ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_BLOCKER_MESSAGES.COLUMN_MISSING */.M3.COLUMN_MISSING, {
+                    column: field.code
+                }));
+            }
+            // ── plain metadata ──
+            for (const key of [
+                'label',
+                'order',
+                'uiConfig',
+                'isSearchable'
+            ]){
+                if (key in changes) patch[key] = changes[key];
+            }
+            if ('selectOptions' in changes) {
+                patch.selectOptions = changes.selectOptions;
+                if (merged.fieldType === _enums_field_type_enum_js__rspack_import_20/* .FieldType.SINGLE_SELECT */.P.SINGLE_SELECT && Array.isArray(changes.selectOptions) && changes.selectOptions.length && !ctx.blocked) {
+                    const values = changes.selectOptions.map((o)=>String(o.value));
+                    const stray = await this.advisoryScalar(ctx, (0,_flusys_nestjs_shared_classes__rspack_import_0.buildQuery)(`SELECT COUNT(*) AS c FROM ${ctx.q(definition.tableName)} WHERE ${ctx.q(field.code)} IS NOT NULL AND ${ctx.q(field.code)} NOT IN (${values.map(()=>'?').join(', ')})`, ctx.driver), values);
+                    if (stray > 0) ctx.warn((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_WARNING_MESSAGES.STRAY_VALUES */.Uu.STRAY_VALUES, {
+                        count: stray
+                    }));
+                }
+            }
+            if ('validationRules' in changes) {
+                patch.validationRules = changes.validationRules;
+                const rules = changes.validationRules ?? {};
+                const isNumber = merged.fieldType === _enums_field_type_enum_js__rspack_import_20/* .FieldType.INTEGER */.P.INTEGER || merged.fieldType === _enums_field_type_enum_js__rspack_import_20/* .FieldType.DECIMAL */.P.DECIMAL;
+                const violating = [];
+                if (isNumber && typeof rules.min === 'number') violating.push(`${ctx.q(field.code)} < ${Number(rules.min)}`);
+                if (isNumber && typeof rules.max === 'number') violating.push(`${ctx.q(field.code)} > ${Number(rules.max)}`);
+                if (!isNumber && typeof rules.minLength === 'number') violating.push(`CHAR_LENGTH(${ctx.q(field.code)}) < ${Number(rules.minLength)}`);
+                if (!isNumber && typeof rules.maxLength === 'number') violating.push(`CHAR_LENGTH(${ctx.q(field.code)}) > ${Number(rules.maxLength)}`);
+                if (violating.length && [
+                    _enums_field_type_enum_js__rspack_import_20/* .FieldType.INTEGER */.P.INTEGER,
+                    _enums_field_type_enum_js__rspack_import_20/* .FieldType.DECIMAL */.P.DECIMAL,
+                    _enums_field_type_enum_js__rspack_import_20/* .FieldType.TEXT */.P.TEXT,
+                    _enums_field_type_enum_js__rspack_import_20/* .FieldType.LONG_TEXT */.P.LONG_TEXT,
+                    _enums_field_type_enum_js__rspack_import_20/* .FieldType.EMAIL */.P.EMAIL
+                ].includes(merged.fieldType)) {
+                    const bad = await this.advisoryScalar(ctx, `SELECT COUNT(*) AS c FROM ${ctx.q(definition.tableName)} WHERE ${ctx.q(field.code)} IS NOT NULL AND (${violating.join(' OR ')})`);
+                    if (bad > 0) ctx.warn((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_WARNING_MESSAGES.RULES_VIOLATED */.Uu.RULES_VIOLATED, {
+                        count: bad
+                    }));
+                }
+            }
+            // ── relation target ──
+            if (merged.fieldType === _enums_field_type_enum_js__rspack_import_20/* .FieldType.RELATION */.P.RELATION) {
+                const targetId = 'relationTargetEntityId' in changes ? changes.relationTargetEntityId : field.relationTargetEntityId;
+                const becomesRelation = field.fieldType !== _enums_field_type_enum_js__rspack_import_20/* .FieldType.RELATION */.P.RELATION;
+                if (!targetId && (becomesRelation || 'relationTargetEntityId' in changes)) {
+                    ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_BLOCKER_MESSAGES.RELATION_TARGET_REQUIRED */.M3.RELATION_TARGET_REQUIRED, {
+                        field: field.code
+                    }));
+                } else if (targetId && (becomesRelation || targetId !== field.relationTargetEntityId)) {
+                    const target = await ctx.qr.manager.getRepository(_entities_entity_definition_entity_js__rspack_import_7/* .EntityDefinition */.f).findOne({
+                        where: {
+                            id: targetId
+                        }
+                    });
+                    if (!target) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_BLOCKER_MESSAGES.RELATION_TARGET_MISSING */.M3.RELATION_TARGET_MISSING));
+                    else if (target.id !== field.relationTargetEntityId) patch.relationTargetEntityId = target.id;
+                }
+            } else if (field.relationTargetEntityId && changes.fieldType !== undefined) {
+                patch.relationTargetEntityId = null;
+            }
+            if ('defaultValue' in changes) {
+                if (changes.defaultValue !== null && changes.defaultValue !== undefined) {
+                    const problem = this.checkValue(merged, changes.defaultValue);
+                    if (problem) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_BLOCKER_MESSAGES.DEFAULT_INVALID */.M3.DEFAULT_INVALID, {
+                        problem
+                    }));
+                }
+                patch.defaultValue = changes.defaultValue ?? null;
+            }
+            // ── type change ──
+            const typeChanged = changes.fieldType !== undefined && changes.fieldType !== field.fieldType;
+            if (typeChanged && table && column) {
+                const conversion = (0,_field_type_conversion_js__rspack_import_13/* .planTypeConversion */.I)(field.fieldType, merged.fieldType, ctx.driver);
+                if (!conversion.supported) {
+                    ctx.block(conversion.reason);
+                } else {
+                    const nonNull = await this.scalar(ctx, `SELECT COUNT(*) AS c FROM ${ctx.q(definition.tableName)} WHERE ${ctx.q(field.code)} IS NOT NULL`);
+                    ctx.setAffectedRows(nonNull);
+                    for (const check of conversion.prechecks){
+                        const where = check.badRowsWhere(ctx.q(field.code), ctx.driver);
+                        const bad = await this.scalar(ctx, `SELECT COUNT(*) AS c FROM ${ctx.q(definition.tableName)} WHERE ${ctx.q(field.code)} IS NOT NULL AND (${where})`);
+                        if (bad > 0) {
+                            ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_BLOCKER_MESSAGES.CONVERSION_BAD_ROWS */.M3.CONVERSION_BAD_ROWS, {
+                                count: bad,
+                                check: check.description,
+                                from: field.fieldType,
+                                to: merged.fieldType
+                            }));
+                        }
+                    }
+                    if (conversion.lossy) {
+                        ctx.warn(conversion.lossy);
+                        ctx.markDestructive();
+                    }
+                    const newDefaultProblem = merged.defaultValue !== null && merged.defaultValue !== undefined ? this.checkValue(merged, merged.defaultValue) : null;
+                    if (newDefaultProblem) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_BLOCKER_MESSAGES.CURRENT_DEFAULT_INVALID */.M3.CURRENT_DEFAULT_INVALID, {
+                        type: merged.fieldType,
+                        problem: newDefaultProblem
+                    }));
+                    if ((merged.fieldType === _enums_field_type_enum_js__rspack_import_20/* .FieldType.SINGLE_SELECT */.P.SINGLE_SELECT || merged.fieldType === _enums_field_type_enum_js__rspack_import_20/* .FieldType.MULTI_SELECT */.P.MULTI_SELECT) && !merged.selectOptions?.length) {
+                        ctx.warn((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_WARNING_MESSAGES.NO_SELECT_OPTIONS_CONVERT */.Uu.NO_SELECT_OPTIONS_CONVERT));
+                    }
+                    if (!ctx.blocked) {
+                        const newDbType = this.adapter.mapFieldType(merged.fieldType, ctx.driver);
+                        if (!conversion.noDbChange) {
+                            const from = (0,_schema_columns_js__rspack_import_17/* .sqlTypeFor */.cg)(field.fieldType, ctx.driver, this.adapter);
+                            const to = (0,_schema_columns_js__rspack_import_17/* .sqlTypeFor */.cg)(merged.fieldType, ctx.driver, this.adapter);
+                            const t = ctx.q(definition.tableName);
+                            const c = ctx.q(field.code);
+                            const nullSql = column.isNullable ? 'NULL' : 'NOT NULL';
+                            const up = ctx.driver === 'postgres' ? `ALTER TABLE ${t} ALTER COLUMN ${c} TYPE ${to} USING ${conversion.using ? conversion.using(c) : `${c}::${to}`}` : `ALTER TABLE ${t} MODIFY ${c} ${to} ${nullSql}`;
+                            const down = ctx.driver === 'postgres' ? `ALTER TABLE ${t} ALTER COLUMN ${c} TYPE ${from} USING ${c}::${from}` : `ALTER TABLE ${t} MODIFY ${c} ${from} ${nullSql}`;
+                            await ctx.rawDdl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_STEP_MESSAGES.CONVERT_TYPE */.EQ.CONVERT_TYPE, {
+                                column: field.code,
+                                from: field.fieldType,
+                                to: merged.fieldType
+                            }), [
+                                up
+                            ], [
+                                down
+                            ]);
+                        }
+                        patch.fieldType = merged.fieldType;
+                        patch.dbType = newDbType;
+                    }
+                }
+            }
+            // ── nullable ──
+            if (changes.nullable !== undefined && changes.nullable !== field.nullable && table && column && !ctx.blocked) {
+                if (changes.nullable === false) {
+                    const nulls = await this.scalar(ctx, `SELECT COUNT(*) AS c FROM ${ctx.q(definition.tableName)} WHERE ${ctx.q(field.code)} IS NULL`);
+                    const value = request.backfillValue ?? merged.defaultValue ?? null;
+                    if (nulls > 0 && value === null) {
+                        ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_BLOCKER_MESSAGES.NULLS_NEED_VALUE */.M3.NULLS_NEED_VALUE, {
+                            count: nulls,
+                            field: field.code
+                        }));
+                    } else if (nulls > 0) {
+                        const problem = this.checkValue(merged, value);
+                        if (problem) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_BLOCKER_MESSAGES.BACKFILL_INVALID */.M3.BACKFILL_INVALID, {
+                            problem
+                        }));
+                        else {
+                            ctx.warn((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_WARNING_MESSAGES.BACKFILL_WILL_SET */.Uu.BACKFILL_WILL_SET, {
+                                count: nulls,
+                                value: JSON.stringify(value)
+                            }));
+                            await ctx.data((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_STEP_MESSAGES.BACKFILL_RECORDS */.EQ.BACKFILL_RECORDS, {
+                                count: nulls
+                            }), `UPDATE ${ctx.q(definition.tableName)} SET ${ctx.q(field.code)} = ${this.adapter.sqlLiteral(this.paramValue(merged.fieldType, value), ctx.driver)} WHERE ${ctx.q(field.code)} IS NULL`, async ()=>{
+                                await ctx.qr.query((0,_flusys_nestjs_shared_classes__rspack_import_0.buildQuery)(`UPDATE ${ctx.q(definition.tableName)} SET ${ctx.q(field.code)} = ? WHERE ${ctx.q(field.code)} IS NULL`, ctx.driver), [
+                                    this.paramValue(merged.fieldType, value)
+                                ]);
+                            });
+                        }
+                    }
+                    if (!ctx.blocked && column.isNullable) {
+                        await this.setRequired(ctx, definition.tableName, field.code, merged.fieldType, true);
+                    }
+                } else if (!column.isNullable) {
+                    await this.setRequired(ctx, definition.tableName, field.code, merged.fieldType, false);
+                }
+                if (!ctx.blocked) patch.nullable = changes.nullable;
+            }
+            // ── unique ──
+            if (changes.unique !== undefined && changes.unique !== field.unique && table && column && !ctx.blocked) {
+                if (changes.unique === true) {
+                    const dups = await this.countDuplicates(ctx, definition.tableName, field.code);
+                    if (dups > 0) {
+                        ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_BLOCKER_MESSAGES.DUPLICATE_VALUES */.M3.DUPLICATE_VALUES, {
+                            count: dups,
+                            field: field.code
+                        }));
+                    } else {
+                        await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_STEP_MESSAGES.ADD_UNIQUE */.EQ.ADD_UNIQUE, {
+                            column: field.code
+                        }), async ()=>{
+                            await (0,_schema_columns_js__rspack_import_17/* .addUnique */.$6)(ctx.qr, table, field.code, ctx.driver, this.adapter);
+                        });
+                    }
+                } else {
+                    await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_STEP_MESSAGES.REMOVE_UNIQUE */.EQ.REMOVE_UNIQUE, {
+                        column: field.code
+                    }), async ()=>this.dropUniques(ctx, table, field.code));
+                }
+                if (!ctx.blocked) patch.unique = changes.unique;
+            }
+            // ── index ──
+            if (changes.isIndexed !== undefined && changes.isIndexed !== field.isIndexed && table && column && !ctx.blocked) {
+                if (changes.isIndexed) {
+                    await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_STEP_MESSAGES.ADD_INDEX */.EQ.ADD_INDEX, {
+                        column: field.code
+                    }), async ()=>{
+                        await ctx.qr.createIndex(table, (0,_schema_columns_js__rspack_import_17/* .plainIndex */.v7)(definition.tableName, field.code, ctx.driver, this.adapter));
+                    });
+                } else {
+                    await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_STEP_MESSAGES.REMOVE_INDEX */.EQ.REMOVE_INDEX, {
+                        column: field.code
+                    }), async ()=>{
+                        for (const idx of this.indexOn(table, field.code, false))await ctx.qr.dropIndex(table, idx);
+                    });
+                }
+                patch.isIndexed = changes.isIndexed;
+            }
+            // ── rename ──
+            if (newCode && table && column) {
+                const taken = fields.find((f)=>f.code === newCode);
+                if (taken) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(taken.deprecatedAt ? _config_message_keys_js__rspack_import_19/* .SCHEMA_BLOCKER_MESSAGES.FIELD_CODE_TAKEN_DEPRECATED */.M3.FIELD_CODE_TAKEN_DEPRECATED : _config_message_keys_js__rspack_import_19/* .SCHEMA_BLOCKER_MESSAGES.FIELD_CODE_TAKEN */.M3.FIELD_CODE_TAKEN, {
+                    code: newCode
+                }));
+                if (impact.length && request.rewriteReferences === false) {
+                    ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_BLOCKER_MESSAGES.RENAME_IN_USE */.M3.RENAME_IN_USE, {
+                        field: field.code,
+                        references: (0,_schema_change_types_js__rspack_import_22/* .describeImpact */.a)(impact)
+                    }));
+                } else if (impact.length) {
+                    ctx.warn((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_WARNING_MESSAGES.REFERENCES_REWRITTEN */.Uu.REFERENCES_REWRITTEN, {
+                        count: impact.length,
+                        code: newCode
+                    }));
+                }
+                if (!ctx.blocked) {
+                    await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_STEP_MESSAGES.RENAME_COLUMN */.EQ.RENAME_COLUMN, {
+                        from: field.code,
+                        to: newCode
+                    }), async ()=>{
+                        await ctx.qr.renameColumn(table, field.code, newCode);
+                    });
+                    // TypeORM moves the index/unique onto the renamed column but keeps its name, which is
+                    // derived from the old code - recreate them so a new field with the old code can have its own.
+                    if (field.isIndexed && !field.unique) {
+                        await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_STEP_MESSAGES.RENAME_INDEX */.EQ.RENAME_INDEX, {
+                            column: field.code
+                        }), async ()=>{
+                            for (const idx of this.indexOn(table, newCode, false))await ctx.qr.dropIndex(table, idx);
+                            await ctx.qr.createIndex(table, (0,_schema_columns_js__rspack_import_17/* .plainIndex */.v7)(definition.tableName, newCode, ctx.driver, this.adapter));
+                        });
+                    }
+                    if (field.unique) {
+                        await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_STEP_MESSAGES.RENAME_INDEX */.EQ.RENAME_INDEX, {
+                            column: field.code
+                        }), async ()=>{
+                            await this.dropUniques(ctx, table, newCode);
+                            await (0,_schema_columns_js__rspack_import_17/* .addUnique */.$6)(ctx.qr, table, newCode, ctx.driver, this.adapter);
+                        });
+                    }
+                    patch.code = newCode;
+                }
+            }
+            if (ctx.blocked) return {
+                operation: _enums_ddl_operation_enum_js__rspack_import_21/* .DdlOperation.ALTER_FIELD */.i.ALTER_FIELD,
+                fieldDefinitionId: field.id,
+                diff: {}
+            };
+            await ctx.metadata(async ()=>{
+                if (Object.keys(patch).length) await ctx.qr.manager.getRepository(_entities_field_definition_entity_js__rspack_import_8/* .FieldDefinition */.c).update(field.id, patch);
+                if (newCode && request.rewriteReferences !== false) {
+                    await this.references.rewriteFieldCode(definition.code, field.code, newCode, ctx.qr.manager);
+                }
+            });
+            const metadataOnly = !structural.length && !newCode;
+            return {
+                operation: newCode ? _enums_ddl_operation_enum_js__rspack_import_21/* .DdlOperation.RENAME_FIELD */.i.RENAME_FIELD : _enums_ddl_operation_enum_js__rspack_import_21/* .DdlOperation.ALTER_FIELD */.i.ALTER_FIELD,
+                fieldDefinitionId: field.id,
+                diff: {
+                    field: field.code,
+                    changed: Object.keys(patch),
+                    before: Object.fromEntries(Object.keys(patch).map((k)=>[
+                            k,
+                            field[k]
+                        ])),
+                    after: patch
+                },
+                bumpVersion: !metadataOnly || Object.keys(patch).some((k)=>[
+                        'selectOptions',
+                        'validationRules',
+                        'defaultValue',
+                        'label',
+                        'relationTargetEntityId'
+                    ].includes(k))
+            };
+        };
+        return {
+            target: this.target('update_field', loaded, user, lockCodes),
+            run,
+            impact
+        };
+    }
+    // ── deprecate / restore / purge ─────────────────────────────────────────────────────
+    async prepareDeprecateField(request, user) {
+        const { field: loadedField, definition: loaded } = await this.loadField(request.fieldDefinitionId);
+        const impact = await this.references.forField(loaded.code, loadedField.code);
+        const run = async (ctx)=>{
+            const { definition, field } = await this.current(ctx, request, loaded.id, loadedField.id);
+            if (field.code !== loadedField.code) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_BLOCKER_MESSAGES.DEFINITION_CHANGED */.M3.DEFINITION_CHANGED));
+            if (field.deprecatedAt) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_BLOCKER_MESSAGES.ALREADY_DEPRECATED */.M3.ALREADY_DEPRECATED, {
+                field: field.code
+            }));
+            if (impact.length) ctx.warn((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_WARNING_MESSAGES.STILL_REFERENCED */.Uu.STILL_REFERENCED, {
+                references: (0,_schema_change_types_js__rspack_import_22/* .describeImpact */.a)(impact)
+            }));
+            const table = await this.requireTable(ctx, definition.tableName);
+            const column = table?.findColumnByName(field.code);
+            if (ctx.blocked) return {
+                operation: _enums_ddl_operation_enum_js__rspack_import_21/* .DdlOperation.MARK_DEPRECATED */.i.MARK_DEPRECATED,
+                fieldDefinitionId: field.id,
+                diff: {}
+            };
+            // A hidden NOT NULL column would make every new record fail (nobody supplies it any more).
+            if (column && !column.isNullable) {
+                await this.setRequired(ctx, definition.tableName, field.code, field.fieldType, false, _config_message_keys_js__rspack_import_19/* .SCHEMA_STEP_MESSAGES.RELAX_DEPRECATED */.EQ.RELAX_DEPRECATED);
+            }
+            await ctx.metadata(async ()=>{
+                await ctx.qr.manager.getRepository(_entities_field_definition_entity_js__rspack_import_8/* .FieldDefinition */.c).update(field.id, {
+                    deprecatedAt: new Date(),
+                    nullable: true
+                });
+            });
+            return {
+                operation: _enums_ddl_operation_enum_js__rspack_import_21/* .DdlOperation.MARK_DEPRECATED */.i.MARK_DEPRECATED,
+                fieldDefinitionId: field.id,
+                diff: {
+                    field: field.code
+                }
+            };
+        };
+        return {
+            target: this.target('deprecate_field', loaded, user),
+            run,
+            impact
+        };
+    }
+    async prepareRestoreField(request, user) {
+        const { field: loadedField, definition: loaded } = await this.loadField(request.fieldDefinitionId);
+        const run = async (ctx)=>{
+            const { definition, field } = await this.current(ctx, request, loaded.id, loadedField.id);
+            if (!field.deprecatedAt) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_BLOCKER_MESSAGES.NOT_DEPRECATED */.M3.NOT_DEPRECATED, {
+                field: field.code
+            }));
+            const table = await this.requireTable(ctx, definition.tableName);
+            if (table && !table.findColumnByName(field.code)) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_BLOCKER_MESSAGES.COLUMN_GONE */.M3.COLUMN_GONE, {
+                column: field.code
+            }));
+            if (ctx.blocked) return {
+                operation: _enums_ddl_operation_enum_js__rspack_import_21/* .DdlOperation.RESTORE_FIELD */.i.RESTORE_FIELD,
+                fieldDefinitionId: field.id,
+                diff: {}
+            };
+            await ctx.metadata(async ()=>{
+                await ctx.qr.manager.getRepository(_entities_field_definition_entity_js__rspack_import_8/* .FieldDefinition */.c).update(field.id, {
+                    deprecatedAt: null
+                });
+            });
+            ctx.warn((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_WARNING_MESSAGES.FIELD_OPTIONAL_AGAIN */.Uu.FIELD_OPTIONAL_AGAIN));
+            return {
+                operation: _enums_ddl_operation_enum_js__rspack_import_21/* .DdlOperation.RESTORE_FIELD */.i.RESTORE_FIELD,
+                fieldDefinitionId: field.id,
+                diff: {
+                    field: field.code
+                }
+            };
+        };
+        return {
+            target: this.target('restore_field', loaded, user),
+            run,
+            impact: []
+        };
+    }
+    async preparePurgeField(request, user) {
+        const { field: loadedField, definition: loaded } = await this.loadField(request.fieldDefinitionId);
+        const impact = await this.references.forField(loaded.code, loadedField.code);
+        const run = async (ctx)=>{
+            const { definition, field } = await this.current(ctx, request, loaded.id, loadedField.id);
+            if (this.changedUnderneath(ctx, loadedField, field)) return {
+                operation: _enums_ddl_operation_enum_js__rspack_import_21/* .DdlOperation.DROP_COLUMN */.i.DROP_COLUMN,
+                fieldDefinitionId: field.id,
+                diff: {}
+            };
+            if (!field.deprecatedAt) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_BLOCKER_MESSAGES.PURGE_REQUIRES_DEPRECATED */.M3.PURGE_REQUIRES_DEPRECATED));
+            if (request.confirmCode !== field.code) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_BLOCKER_MESSAGES.PURGE_CONFIRM_CODE */.M3.PURGE_CONFIRM_CODE, {
+                code: field.code
+            }));
+            if (impact.length) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_BLOCKER_MESSAGES.PURGE_IN_USE */.M3.PURGE_IN_USE, {
+                field: field.code,
+                references: (0,_schema_change_types_js__rspack_import_22/* .describeImpact */.a)(impact)
+            }));
+            const table = await this.requireTable(ctx, definition.tableName);
+            const column = table?.findColumnByName(field.code);
+            if (ctx.blocked) return {
+                operation: _enums_ddl_operation_enum_js__rspack_import_21/* .DdlOperation.DROP_COLUMN */.i.DROP_COLUMN,
+                fieldDefinitionId: field.id,
+                diff: {}
+            };
+            if (table && column) {
+                const values = await this.scalar(ctx, `SELECT COUNT(*) AS c FROM ${ctx.q(definition.tableName)} WHERE ${ctx.q(field.code)} IS NOT NULL`);
+                ctx.setAffectedRows(values);
+                ctx.warn((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_WARNING_MESSAGES.VALUES_DELETED */.Uu.VALUES_DELETED, {
+                    count: values
+                }));
+                await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_STEP_MESSAGES.DROP_COLUMN */.EQ.DROP_COLUMN, {
+                    column: field.code
+                }), async ()=>{
+                    await ctx.qr.dropColumn(table, column);
+                });
+            } else {
+                ctx.warn((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_WARNING_MESSAGES.COLUMN_ALREADY_MISSING */.Uu.COLUMN_ALREADY_MISSING));
+            }
+            ctx.markDestructive();
+            await ctx.metadata(async ()=>{
+                await ctx.qr.manager.getRepository(_entities_field_definition_entity_js__rspack_import_8/* .FieldDefinition */.c).delete(field.id);
+            });
+            return {
+                operation: _enums_ddl_operation_enum_js__rspack_import_21/* .DdlOperation.DROP_COLUMN */.i.DROP_COLUMN,
+                fieldDefinitionId: null,
+                diff: {
+                    field: field.code,
+                    fieldType: field.fieldType
+                }
+            };
+        };
+        return {
+            target: this.target('purge_field', loaded, user),
+            run,
+            impact
+        };
+    }
+    // ── entity level ────────────────────────────────────────────────────────────────────
+    async prepareUpdateEntity(request, user) {
+        const { definition: loaded } = await this.loadEntity(request.entityDefinitionId);
+        const changes = request.changes ?? {};
+        this.rejectUnknownKeys(changes, _dtos_schema_change_dto_js__rspack_import_6/* .ENTITY_CHANGE_KEYS */.Oi, 'entity');
+        if (changes.status !== undefined && ![
+            _enums_entity_status_enum_js__rspack_import_23/* .EntityStatus.ACTIVE */.c.ACTIVE,
+            _enums_entity_status_enum_js__rspack_import_23/* .EntityStatus.DEPRECATED */.c.DEPRECATED
+        ].includes(changes.status)) {
+            throw new _nestjs_common__rspack_import_2.BadRequestException({
+                message: "status must be 'ACTIVE' or 'DEPRECATED'.",
+                messageKey: _config_message_keys_js__rspack_import_19/* .ENTITY_DEFINITION_MESSAGES.INVALID_STATUS */.pL.INVALID_STATUS
+            });
+        }
+        this.validateChanges(_dtos_schema_change_dto_js__rspack_import_6/* .EntityChangesDto */.OW, changes);
+        const impact = changes.status === _enums_entity_status_enum_js__rspack_import_23/* .EntityStatus.DEPRECATED */.c.DEPRECATED ? await this.references.forEntity(loaded.code) : [];
+        const run = async (ctx)=>{
+            const { definition } = await this.current(ctx, request, loaded.id);
+            const patch = {};
+            for (const key of [
+                'label',
+                'description',
+                'uiConfig',
+                'status'
+            ]){
+                if (key in changes) patch[key] = changes[key];
+            }
+            const wantsSoft = changes.isSoftDeleteEnabled;
+            const wantsAudit = changes.isAuditEnabled;
+            const touchesColumns = wantsSoft === true && !definition.isSoftDeleteEnabled || wantsAudit === true && !definition.isAuditEnabled;
+            const table = touchesColumns ? await this.requireTable(ctx, definition.tableName) : undefined;
+            if (ctx.blocked) return {
+                operation: _enums_ddl_operation_enum_js__rspack_import_21/* .DdlOperation.ALTER_ENTITY */.i.ALTER_ENTITY,
+                diff: {}
+            };
+            if (wantsSoft !== undefined && wantsSoft !== definition.isSoftDeleteEnabled) {
+                if (wantsSoft && table) {
+                    if (!table.findColumnByName('deleted_at')) {
+                        await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_STEP_MESSAGES.ADD_DELETED_AT */.EQ.ADD_DELETED_AT), async ()=>{
+                            await ctx.qr.addColumn(table, (0,_schema_columns_js__rspack_import_17/* .softDeleteColumn */.OG)());
+                        });
+                    }
+                } else if (!wantsSoft) {
+                    ctx.warn((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_WARNING_MESSAGES.SOFT_DELETE_OFF */.Uu.SOFT_DELETE_OFF));
+                    ctx.markDestructive();
+                }
+                patch.isSoftDeleteEnabled = wantsSoft;
+            }
+            if (wantsAudit !== undefined && wantsAudit !== definition.isAuditEnabled) {
+                if (wantsAudit && table) {
+                    const missing = (0,_schema_columns_js__rspack_import_17/* .auditColumns */.HK)(ctx.driver).filter((c)=>!table.findColumnByName(c.name));
+                    if (missing.length) {
+                        await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_STEP_MESSAGES.ADD_AUDIT_COLUMNS */.EQ.ADD_AUDIT_COLUMNS), async ()=>{
+                            for (const c of missing)await ctx.qr.addColumn(table, c);
+                        });
+                    }
+                } else if (!wantsAudit) {
+                    ctx.warn((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_WARNING_MESSAGES.AUDIT_OFF */.Uu.AUDIT_OFF));
+                }
+                patch.isAuditEnabled = wantsAudit;
+            }
+            if (changes.status === _enums_entity_status_enum_js__rspack_import_23/* .EntityStatus.DEPRECATED */.c.DEPRECATED && impact.length) {
+                ctx.warn((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_WARNING_MESSAGES.ENTITY_REFERENCED */.Uu.ENTITY_REFERENCED, {
+                    count: impact.length
+                }));
+            }
+            await ctx.metadata(async ()=>{
+                if (Object.keys(patch).length) await ctx.qr.manager.getRepository(_entities_entity_definition_entity_js__rspack_import_7/* .EntityDefinition */.f).update(definition.id, patch);
+            });
+            return {
+                operation: _enums_ddl_operation_enum_js__rspack_import_21/* .DdlOperation.ALTER_ENTITY */.i.ALTER_ENTITY,
+                diff: {
+                    changed: Object.keys(patch),
+                    after: patch
+                }
+            };
+        };
+        return {
+            target: this.target('update_entity', loaded, user),
+            run,
+            impact
+        };
+    }
+    /** `"orders.customer_id", ...` - relation fields of other entities that point at this one. */ async relationsInto(ctx, definition) {
+        const pointing = (await ctx.qr.manager.getRepository(_entities_field_definition_entity_js__rspack_import_8/* .FieldDefinition */.c).find({
+            where: {
+                relationTargetEntityId: definition.id
+            }
+        })).filter((f)=>f.entityDefinitionId !== definition.id);
+        if (!pointing.length) return null;
+        const owners = await ctx.qr.manager.getRepository(_entities_entity_definition_entity_js__rspack_import_7/* .EntityDefinition */.f).find({
+            where: {
+                id: (0,typeorm__rspack_import_5.In)([
+                    ...new Set(pointing.map((f)=>f.entityDefinitionId))
+                ])
+            }
+        });
+        const codeOf = new Map(owners.map((o)=>[
+                o.id,
+                o.code
+            ]));
+        return pointing.map((f)=>`"${codeOf.get(f.entityDefinitionId) ?? f.entityDefinitionId}.${f.code}"`).join(', ');
+    }
+    async prepareDropEntity(request, user) {
+        const { definition: loaded } = await this.loadEntity(request.entityDefinitionId);
+        const impact = await this.references.forEntity(loaded.code);
+        const run = async (ctx)=>{
+            const { definition } = await this.current(ctx, request, loaded.id);
+            if (request.confirmCode !== definition.code) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_BLOCKER_MESSAGES.DROP_CONFIRM_CODE */.M3.DROP_CONFIRM_CODE, {
+                code: definition.code
+            }));
+            if (impact.length) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_BLOCKER_MESSAGES.DROP_IN_USE */.M3.DROP_IN_USE, {
+                references: (0,_schema_change_types_js__rspack_import_22/* .describeImpact */.a)(impact)
+            }));
+            const relations = await this.relationsInto(ctx, definition);
+            if (relations) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_BLOCKER_MESSAGES.DROP_RELATION_IN_USE */.M3.DROP_RELATION_IN_USE, {
+                fields: relations
+            }));
+            const table = await ctx.qr.getTable(definition.tableName);
+            if (ctx.blocked) return {
+                operation: _enums_ddl_operation_enum_js__rspack_import_21/* .DdlOperation.DROP_TABLE */.i.DROP_TABLE,
+                diff: {}
+            };
+            if (table) {
+                const rows = await this.scalar(ctx, `SELECT COUNT(*) AS c FROM ${ctx.q(definition.tableName)}`);
+                ctx.setAffectedRows(rows);
+                ctx.warn((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_WARNING_MESSAGES.RECORDS_DELETED */.Uu.RECORDS_DELETED, {
+                    count: rows
+                }));
+                await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_STEP_MESSAGES.DROP_TABLE */.EQ.DROP_TABLE, {
+                    table: definition.tableName
+                }), async ()=>{
+                    await ctx.qr.dropTable(table);
+                });
+            } else {
+                ctx.warn((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_WARNING_MESSAGES.TABLE_ALREADY_MISSING */.Uu.TABLE_ALREADY_MISSING));
+            }
+            ctx.markDestructive();
+            await ctx.metadata(async ()=>{
+                await ctx.qr.manager.getRepository(_entities_field_definition_entity_js__rspack_import_8/* .FieldDefinition */.c).delete({
+                    entityDefinitionId: definition.id
+                });
+                await ctx.qr.manager.getRepository(_entities_entity_definition_entity_js__rspack_import_7/* .EntityDefinition */.f).delete(definition.id);
+            });
+            return {
+                operation: _enums_ddl_operation_enum_js__rspack_import_21/* .DdlOperation.DROP_TABLE */.i.DROP_TABLE,
+                diff: {
+                    entity: definition.code
+                },
+                bumpVersion: false,
+                afterCommit: async ()=>this.permissions.deprovisionForEntity(definition)
+            };
+        };
+        return {
+            target: this.target('drop_entity', loaded, user),
+            run,
+            impact
+        };
+    }
+    // ── inspection and repair ───────────────────────────────────────────────────────────
+    diff(definition, fields, table, driver) {
+        const findings = [];
+        if (!table) {
+            findings.push({
+                kind: 'missing_table',
+                severity: 'error',
+                ...(0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_FINDING_MESSAGES.MISSING_TABLE */.Vu.MISSING_TABLE, {
+                    table: definition.tableName
+                }),
+                repairable: true
+            });
+            return findings;
+        }
+        const known = new Set([
+            'id',
+            'created_at',
+            'updated_at'
+        ]);
+        if (definition.isSoftDeleteEnabled) known.add('deleted_at');
+        if (definition.isAuditEnabled) (0,_schema_columns_js__rspack_import_17/* .auditColumns */.HK)(driver).forEach((c)=>known.add(c.name));
+        for (const name of known){
+            if (!table.findColumnByName(name)) {
+                findings.push({
+                    kind: 'missing_column',
+                    severity: 'error',
+                    field: name,
+                    ...(0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_FINDING_MESSAGES.SYSTEM_COLUMN_MISSING */.Vu.SYSTEM_COLUMN_MISSING, {
+                        column: name
+                    }),
+                    repairable: name !== 'id'
+                });
+            }
+        }
+        for (const field of fields){
+            known.add(field.code);
+            const column = table.findColumnByName(field.code);
+            if (!column) {
+                findings.push({
+                    kind: 'missing_column',
+                    severity: field.deprecatedAt ? 'warning' : 'error',
+                    field: field.code,
+                    ...(0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_FINDING_MESSAGES.COLUMN_MISSING */.Vu.COLUMN_MISSING, {
+                        column: field.code
+                    }),
+                    repairable: true
+                });
+                continue;
+            }
+            const expected = (0,_schema_columns_js__rspack_import_17/* .typeFamily */.jp)(this.adapter.mapFieldType(field.fieldType, driver));
+            const actual = (0,_schema_columns_js__rspack_import_17/* .typeFamily */.jp)(column.type);
+            const uuidAsChar = expected === 'uuid' && actual === 'varchar';
+            if (expected !== actual && !uuidAsChar) {
+                findings.push({
+                    kind: 'type_mismatch',
+                    severity: 'error',
+                    field: field.code,
+                    ...(0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_FINDING_MESSAGES.TYPE_MISMATCH */.Vu.TYPE_MISMATCH, {
+                        column: field.code,
+                        actual: column.type,
+                        fieldType: field.fieldType,
+                        expected
+                    }),
+                    repairable: false
+                });
+            }
+            if (!field.deprecatedAt && !field.nullable && column.isNullable) {
+                findings.push({
+                    kind: 'nullability_mismatch',
+                    severity: 'warning',
+                    field: field.code,
+                    ...(0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_FINDING_MESSAGES.REQUIRED_BUT_NULLABLE */.Vu.REQUIRED_BUT_NULLABLE, {
+                        column: field.code
+                    }),
+                    repairable: true
+                });
+            }
+            if (field.nullable && !column.isNullable) {
+                findings.push({
+                    kind: 'nullability_mismatch',
+                    severity: 'warning',
+                    field: field.code,
+                    ...(0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_FINDING_MESSAGES.OPTIONAL_BUT_NOT_NULL */.Vu.OPTIONAL_BUT_NOT_NULL, {
+                        column: field.code
+                    }),
+                    repairable: true
+                });
+            }
+            if (field.isIndexed && !field.unique && this.indexOn(table, field.code, false).length === 0) {
+                findings.push({
+                    kind: 'missing_index',
+                    severity: 'warning',
+                    field: field.code,
+                    ...(0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_FINDING_MESSAGES.INDEX_MISSING */.Vu.INDEX_MISSING, {
+                        column: field.code
+                    }),
+                    repairable: true
+                });
+            }
+            if (field.unique && !this.hasUnique(table, field.code)) {
+                findings.push({
+                    kind: 'missing_unique',
+                    severity: 'warning',
+                    field: field.code,
+                    ...(0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_FINDING_MESSAGES.UNIQUE_MISSING */.Vu.UNIQUE_MISSING, {
+                        column: field.code
+                    }),
+                    repairable: true
+                });
+            }
+            if (field.dbType && field.dbType !== this.adapter.mapFieldType(field.fieldType, driver)) {
+                findings.push({
+                    kind: 'stale_metadata',
+                    severity: 'warning',
+                    field: field.code,
+                    ...(0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_FINDING_MESSAGES.STALE_METADATA */.Vu.STALE_METADATA, {
+                        dbType: field.dbType,
+                        driver,
+                        fieldType: field.fieldType
+                    }),
+                    repairable: false
+                });
+            }
+        }
+        for (const column of table.columns){
+            if (!known.has(column.name)) {
+                findings.push({
+                    kind: 'extra_column',
+                    severity: 'warning',
+                    field: column.name,
+                    ...(0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_FINDING_MESSAGES.EXTRA_COLUMN */.Vu.EXTRA_COLUMN, {
+                        column: column.name
+                    }),
+                    repairable: false
+                });
+            }
+        }
+        return findings;
+    }
+    async prepareRepair(request, user) {
+        const { definition: loaded } = await this.loadEntity(request.entityDefinitionId);
+        const run = async (ctx)=>{
+            const { definition, fields } = await this.current(ctx, request, loaded.id);
+            const table = await ctx.qr.getTable(definition.tableName);
+            const findings = this.diff(definition, fields, table ?? undefined, ctx.driver);
+            // Only what a statement actually ran for - a finding that is skipped or only warned about is not "fixed".
+            const fixed = [];
+            if (!table) {
+                const columns = [
+                    ...(0,_schema_columns_js__rspack_import_17/* .buildSystemColumns */.Rm)(definition, ctx.driver),
+                    ...fields.map((f)=>(0,_schema_columns_js__rspack_import_17/* .buildFieldColumn */.fu)(f, ctx.driver, this.adapter, {
+                            enforceNotNull: false,
+                            withUnique: false
+                        }))
+                ];
+                const uniques = fields.filter((f)=>f.unique).map((f)=>(0,_schema_columns_js__rspack_import_17/* .tableUnique */.uy)(definition.tableName, f.code, ctx.driver, this.adapter));
+                const recreated = new typeorm__rspack_import_5.Table({
+                    name: definition.tableName,
+                    columns,
+                    uniques
+                });
+                await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_STEP_MESSAGES.RECREATE_TABLE */.EQ.RECREATE_TABLE, {
+                    table: definition.tableName
+                }), async ()=>{
+                    await ctx.qr.createTable(recreated, false);
+                });
+                fixed.push('missing_table');
+                for (const indexed of fields.filter((f)=>f.isIndexed && !f.unique)){
+                    await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_STEP_MESSAGES.RECREATE_INDEX */.EQ.RECREATE_INDEX, {
+                        column: indexed.code
+                    }), async ()=>{
+                        await ctx.qr.createIndex(recreated, (0,_schema_columns_js__rspack_import_17/* .plainIndex */.v7)(definition.tableName, indexed.code, ctx.driver, this.adapter));
+                    });
+                    fixed.push(`missing_index:${indexed.code}`);
+                }
+                ctx.warn((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_WARNING_MESSAGES.TABLE_RECREATED_EMPTY */.Uu.TABLE_RECREATED_EMPTY));
+                ctx.markDestructive();
+                return {
+                    operation: _enums_ddl_operation_enum_js__rspack_import_21/* .DdlOperation.REPAIR */.i.REPAIR,
+                    diff: {
+                        fixed,
+                        manual: 0
+                    }
+                };
+            }
+            for (const finding of findings){
+                if (!finding.repairable || !finding.field) continue;
+                const field = fields.find((f)=>f.code === finding.field);
+                switch(finding.kind){
+                    case 'missing_column':
+                        {
+                            if (!field) {
+                                const sys = [
+                                    (0,_schema_columns_js__rspack_import_17/* .softDeleteColumn */.OG)(),
+                                    ...(0,_schema_columns_js__rspack_import_17/* .auditColumns */.HK)(ctx.driver)
+                                ].find((c)=>c.name === finding.field);
+                                if (!sys) break;
+                                await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_STEP_MESSAGES.ADD_SYSTEM_COLUMN */.EQ.ADD_SYSTEM_COLUMN, {
+                                    column: sys.name
+                                }), async ()=>ctx.qr.addColumn(table, sys));
+                            } else {
+                                await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_STEP_MESSAGES.ADD_MISSING_COLUMN */.EQ.ADD_MISSING_COLUMN, {
+                                    column: field.code
+                                }), async ()=>{
+                                    await ctx.qr.addColumn(table, (0,_schema_columns_js__rspack_import_17/* .buildFieldColumn */.fu)(field, ctx.driver, this.adapter, {
+                                        enforceNotNull: false,
+                                        withUnique: false
+                                    }));
+                                });
+                                // Re-added columns start empty, so a required field stays nullable until its records have values.
+                                const rows = !field.nullable && !field.deprecatedAt ? await this.scalar(ctx, `SELECT COUNT(*) AS c FROM ${ctx.q(definition.tableName)}`) : 0;
+                                if (rows > 0) ctx.warn((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_WARNING_MESSAGES.REQUIRED_HAS_NULLS */.Uu.REQUIRED_HAS_NULLS, {
+                                    field: field.code,
+                                    count: rows
+                                }));
+                            }
+                            fixed.push(`missing_column:${finding.field}`);
+                            break;
+                        }
+                    case 'missing_index':
+                        await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_STEP_MESSAGES.RECREATE_INDEX */.EQ.RECREATE_INDEX, {
+                            column: finding.field
+                        }), async ()=>{
+                            await ctx.qr.createIndex(table, (0,_schema_columns_js__rspack_import_17/* .plainIndex */.v7)(definition.tableName, finding.field, ctx.driver, this.adapter));
+                        });
+                        fixed.push(`missing_index:${finding.field}`);
+                        break;
+                    case 'missing_unique':
+                        {
+                            const code = finding.field;
+                            const dups = await this.countDuplicates(ctx, definition.tableName, code);
+                            if (dups > 0) ctx.warn((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_WARNING_MESSAGES.UNIQUE_NOT_RECREATED */.Uu.UNIQUE_NOT_RECREATED, {
+                                field: code,
+                                count: dups
+                            }));
+                            else {
+                                await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_STEP_MESSAGES.RECREATE_UNIQUE */.EQ.RECREATE_UNIQUE, {
+                                    column: code
+                                }), async ()=>{
+                                    await (0,_schema_columns_js__rspack_import_17/* .addUnique */.$6)(ctx.qr, table, code, ctx.driver, this.adapter);
+                                });
+                                fixed.push(`missing_unique:${finding.field}`);
+                            }
+                            break;
+                        }
+                    case 'nullability_mismatch':
+                        {
+                            const column = field && table.findColumnByName(field.code);
+                            if (!field || !column) break;
+                            if (!field.nullable && column.isNullable) {
+                                const nulls = await this.scalar(ctx, `SELECT COUNT(*) AS c FROM ${ctx.q(definition.tableName)} WHERE ${ctx.q(field.code)} IS NULL`);
+                                if (nulls > 0) ctx.warn((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_WARNING_MESSAGES.REQUIRED_HAS_NULLS */.Uu.REQUIRED_HAS_NULLS, {
+                                    field: field.code,
+                                    count: nulls
+                                }));
+                                else {
+                                    await this.setRequired(ctx, definition.tableName, field.code, field.fieldType, true);
+                                    fixed.push(`nullability:${field.code}`);
+                                }
+                            } else if (field.nullable && !column.isNullable) {
+                                await this.setRequired(ctx, definition.tableName, field.code, field.fieldType, false);
+                                fixed.push(`nullability:${field.code}`);
+                            }
+                            break;
+                        }
+                    default:
+                        break;
+                }
+            }
+            const manual = findings.filter((f)=>!f.repairable);
+            for (const f of manual)ctx.warn((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_WARNING_MESSAGES.NEEDS_MANUAL_ATTENTION */.Uu.NEEDS_MANUAL_ATTENTION, {
+                finding: (0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(f.messageKey, f.messageVariables)
+            }));
+            if (fixed.length === 0 && manual.length === 0) ctx.warn((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_WARNING_MESSAGES.NOTHING_TO_REPAIR */.Uu.NOTHING_TO_REPAIR));
+            return {
+                operation: _enums_ddl_operation_enum_js__rspack_import_21/* .DdlOperation.REPAIR */.i.REPAIR,
+                diff: {
+                    fixed,
+                    manual: manual.length
+                },
+                bumpVersion: fixed.length > 0
+            };
+        };
+        return {
+            target: this.target('repair', loaded, user),
+            run,
+            impact: []
+        };
+    }
+}
+SchemaEvolutionService = _ts_decorate([
+    (0,_nestjs_common__rspack_import_2.Injectable)({
+        scope: _nestjs_common__rspack_import_2.Scope.REQUEST
+    }),
+    _ts_param(0, (0,_nestjs_common__rspack_import_2.Inject)(_entity_builder_datasource_provider_js__rspack_import_10/* .EntityBuilderDataSourceProvider */.D)),
+    _ts_param(1, (0,_nestjs_common__rspack_import_2.Inject)(_schema_dialect_adapter_service_js__rspack_import_18/* .SchemaDialectAdapterService */.I)),
+    _ts_param(2, (0,_nestjs_common__rspack_import_2.Inject)(_schema_change_executor_service_js__rspack_import_16/* .SchemaChangeExecutor */.T)),
+    _ts_param(3, (0,_nestjs_common__rspack_import_2.Inject)(_reference_scanner_service_js__rspack_import_15/* .ReferenceScannerService */.t)),
+    _ts_param(4, (0,_nestjs_common__rspack_import_2.Inject)(_entity_permission_service_js__rspack_import_11/* .EntityPermissionService */.u)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _entity_builder_datasource_provider_js__rspack_import_10/* .EntityBuilderDataSourceProvider */.D === "undefined" ? Object : _entity_builder_datasource_provider_js__rspack_import_10/* .EntityBuilderDataSourceProvider */.D,
+        typeof _schema_dialect_adapter_service_js__rspack_import_18/* .SchemaDialectAdapterService */.I === "undefined" ? Object : _schema_dialect_adapter_service_js__rspack_import_18/* .SchemaDialectAdapterService */.I,
+        typeof _schema_change_executor_service_js__rspack_import_16/* .SchemaChangeExecutor */.T === "undefined" ? Object : _schema_change_executor_service_js__rspack_import_16/* .SchemaChangeExecutor */.T,
+        typeof _reference_scanner_service_js__rspack_import_15/* .ReferenceScannerService */.t === "undefined" ? Object : _reference_scanner_service_js__rspack_import_15/* .ReferenceScannerService */.t,
+        typeof _entity_permission_service_js__rspack_import_11/* .EntityPermissionService */.u === "undefined" ? Object : _entity_permission_service_js__rspack_import_11/* .EntityPermissionService */.u
+    ])
+], SchemaEvolutionService);
+
+__webpack_require__.d(__webpack_exports__, {
+  _: () => (SchemaEvolutionService)
+}, {
+  C: isDestructiveSchemaAction
+});
+
+
+},
+3474(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+/* import */ var _flusys_nestjs_shared_classes__rspack_import_0 = __webpack_require__(6937);
+/* import */ var _flusys_nestjs_shared_utils__rspack_import_1 = __webpack_require__(9216);
+/* import */ var _nestjs_common__rspack_import_2 = __webpack_require__(6157);
+/* import */ var typeorm__rspack_import_3 = __webpack_require__(7158);
+/* import */ var _config_message_keys_js__rspack_import_17 = __webpack_require__(5732);
+/* import */ var _entities_entity_definition_entity_js__rspack_import_4 = __webpack_require__(3189);
+/* import */ var _entities_field_definition_entity_js__rspack_import_5 = __webpack_require__(2206);
+/* import */ var _entities_flow_definition_entity_js__rspack_import_6 = __webpack_require__(3770);
+/* import */ var _enums_ddl_operation_enum_js__rspack_import_20 = __webpack_require__(9949);
+/* import */ var _enums_entity_status_enum_js__rspack_import_21 = __webpack_require__(1313);
+/* import */ var _enums_field_type_enum_js__rspack_import_19 = __webpack_require__(9614);
+/* import */ var _flow_engine_flow_errors_js__rspack_import_7 = __webpack_require__(8542);
+/* import */ var _entity_builder_datasource_provider_js__rspack_import_8 = __webpack_require__(424);
+/* import */ var _entity_flow_scaffold_js__rspack_import_9 = __webpack_require__(8271);
+/* import */ var _entity_permission_service_js__rspack_import_10 = __webpack_require__(1462);
+/* import */ var _field_value_validator_js__rspack_import_11 = __webpack_require__(3525);
+/* import */ var _flow_definition_service_js__rspack_import_12 = __webpack_require__(4921);
+/* import */ var _identifier_rules_js__rspack_import_13 = __webpack_require__(413);
+/* import */ var _schema_change_executor_service_js__rspack_import_14 = __webpack_require__(6605);
+/* import */ var _schema_columns_js__rspack_import_15 = __webpack_require__(5313);
+/* import */ var _schema_dialect_adapter_service_js__rspack_import_16 = __webpack_require__(7259);
+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 SchemaSyncService {
+    dataSourceProvider;
+    dialectAdapter;
+    executor;
+    entityPermissionService;
+    flowDefinitionService;
+    logger = new _nestjs_common__rspack_import_2.Logger(SchemaSyncService.name);
+    constructor(dataSourceProvider, dialectAdapter, executor, entityPermissionService, flowDefinitionService){
+        this.dataSourceProvider = dataSourceProvider;
+        this.dialectAdapter = dialectAdapter;
+        this.executor = executor;
+        this.entityPermissionService = entityPermissionService;
+        this.flowDefinitionService = flowDefinitionService;
+    }
+    validateCreateRequest(dto) {
+        (0,_identifier_rules_js__rspack_import_13/* .assertValidIdentifier */.kV)(dto.code, 'entity');
+        const fields = dto.fields ?? [];
+        for (const field of fields){
+            (0,_identifier_rules_js__rspack_import_13/* .assertValidIdentifier */.kV)(field.code, 'field');
+            (0,_identifier_rules_js__rspack_import_13/* .assertIndexableField */.fY)(field);
+        }
+        const duplicate = fields.map((f)=>f.code).find((code, index, all)=>all.indexOf(code) !== index);
+        if (duplicate) {
+            throw new _nestjs_common__rspack_import_2.BadRequestException({
+                message: `Field code '${duplicate}' is defined more than once.`,
+                messageKey: _config_message_keys_js__rspack_import_17/* .SCHEMA_MESSAGES.DUPLICATE_FIELD_CODE */.Hu.DUPLICATE_FIELD_CODE,
+                messageVariables: {
+                    code: duplicate
+                }
+            });
+        }
+    }
+    async createTarget(dto, user) {
+        const lockCodes = await (0,_schema_change_executor_service_js__rspack_import_14/* .relationTargetCodes */.e)(this.dataSourceProvider, (dto.fields ?? []).map((f)=>f.relationTargetEntityId));
+        return {
+            action: 'create_entity',
+            entityDefinitionId: null,
+            entityCode: dto.code,
+            tableName: `${(/* inlined export .ENTITY_TABLE_PREFIX */"eb_")}${dto.code}`,
+            user,
+            lockCodes
+        };
+    }
+    createRun(dto, user, created) {
+        const tableName = `${(/* inlined export .ENTITY_TABLE_PREFIX */"eb_")}${dto.code}`;
+        const fieldSpecs = dto.fields ?? [];
+        const flowEndpoints = dto.flowEndpoints ?? [];
+        const isSoftDeleteEnabled = dto.isSoftDeleteEnabled ?? true;
+        const isAuditEnabled = dto.isAuditEnabled ?? true;
+        return async (ctx)=>{
+            const schemaExpr = ctx.driver === 'postgres' ? 'current_schema()' : 'DATABASE()';
+            const taken = await ctx.qr.query((0,_flusys_nestjs_shared_classes__rspack_import_0.buildQuery)(`SELECT table_name FROM information_schema.tables WHERE table_schema = ${schemaExpr} AND table_name = ?`, ctx.driver), [
+                tableName
+            ]);
+            if (taken.length) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_17/* .SCHEMA_BLOCKER_MESSAGES.TABLE_EXISTS */.M3.TABLE_EXISTS, {
+                table: tableName
+            }));
+            const definitions = ctx.qr.manager.getRepository(_entities_entity_definition_entity_js__rspack_import_4/* .EntityDefinition */.f);
+            const known = await definitions.findOne({
+                where: {
+                    code: dto.code
+                }
+            });
+            if (known) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_17/* .SCHEMA_BLOCKER_MESSAGES.ENTITY_CODE_EXISTS */.M3.ENTITY_CODE_EXISTS, {
+                code: dto.code
+            }));
+            for (const spec of fieldSpecs.filter((f)=>f.fieldType === _enums_field_type_enum_js__rspack_import_19/* .FieldType.RELATION */.P.RELATION)){
+                if (!spec.relationTargetEntityId) {
+                    ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_17/* .SCHEMA_BLOCKER_MESSAGES.RELATION_TARGET_REQUIRED */.M3.RELATION_TARGET_REQUIRED, {
+                        field: spec.code
+                    }));
+                    continue;
+                }
+                const target = await definitions.findOne({
+                    where: {
+                        id: spec.relationTargetEntityId
+                    }
+                });
+                if (!target) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_17/* .SCHEMA_BLOCKER_MESSAGES.RELATION_FIELD_TARGET_MISSING */.M3.RELATION_FIELD_TARGET_MISSING, {
+                    field: spec.code
+                }));
+            }
+            const withDefault = fieldSpecs.filter((f)=>f.defaultValue !== undefined && f.defaultValue !== null);
+            const { errors: defaultErrors } = (0,_field_value_validator_js__rspack_import_11/* .validateRecord */.e)(withDefault.map((f)=>({
+                    code: f.code,
+                    label: f.label,
+                    fieldType: f.fieldType,
+                    nullable: true,
+                    defaultValue: null,
+                    selectOptions: f.selectOptions ?? null,
+                    validationRules: f.validationRules ?? null
+                })), Object.fromEntries(withDefault.map((f)=>[
+                    f.code,
+                    f.defaultValue
+                ])), 'insert');
+            for (const error of defaultErrors)ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_17/* .SCHEMA_BLOCKER_MESSAGES.DEFAULT_INVALID */.M3.DEFAULT_INVALID, {
+                problem: (0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(error.messageKey, error.messageVariables)
+            }));
+            if (flowEndpoints.length) {
+                const slug = (0,_entity_flow_scaffold_js__rspack_import_9/* .entityFlowSlug */.x2)(dto.code);
+                const clash = await ctx.qr.manager.getRepository(_entities_flow_definition_entity_js__rspack_import_6/* .FlowDefinition */.G).findOne({
+                    select: {
+                        slug: true
+                    },
+                    where: {
+                        slug
+                    },
+                    withDeleted: true
+                });
+                if (clash) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_17/* .SCHEMA_BLOCKER_MESSAGES.FLOW_SLUG_TAKEN */.M3.FLOW_SLUG_TAKEN, {
+                    slug
+                }));
+            }
+            if (ctx.blocked) return {
+                operation: _enums_ddl_operation_enum_js__rspack_import_20/* .DdlOperation.CREATE_TABLE */.i.CREATE_TABLE,
+                diff: {}
+            };
+            const columns = fieldSpecs.map((spec)=>(0,_schema_columns_js__rspack_import_15/* .buildFieldColumn */.fu)({
+                    code: spec.code,
+                    fieldType: spec.fieldType,
+                    dbType: '',
+                    nullable: spec.nullable ?? true,
+                    unique: spec.unique ?? false
+                }, ctx.driver, this.dialectAdapter, {
+                    enforceNotNull: true,
+                    withUnique: true
+                }));
+            const table = new typeorm__rspack_import_3.Table({
+                name: tableName,
+                columns: [
+                    ...(0,_schema_columns_js__rspack_import_15/* .buildSystemColumns */.Rm)({
+                        isSoftDeleteEnabled,
+                        isAuditEnabled
+                    }, ctx.driver),
+                    ...columns
+                ]
+            });
+            await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_17/* .SCHEMA_STEP_MESSAGES.CREATE_TABLE */.EQ.CREATE_TABLE, {
+                table: tableName
+            }), async ()=>{
+                await ctx.qr.createTable(table, false);
+            });
+            for (const spec of fieldSpecs.filter((f)=>f.isIndexed && !f.unique)){
+                await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_17/* .SCHEMA_STEP_MESSAGES.ADD_INDEX */.EQ.ADD_INDEX, {
+                    column: spec.code
+                }), async ()=>{
+                    await ctx.qr.createIndex(table, (0,_schema_columns_js__rspack_import_15/* .plainIndex */.v7)(tableName, spec.code, ctx.driver, this.dialectAdapter));
+                });
+            }
+            await ctx.metadata(async ()=>{
+                const definitionRepo = ctx.qr.manager.getRepository(_entities_entity_definition_entity_js__rspack_import_4/* .EntityDefinition */.f);
+                const definition = await definitionRepo.save(definitionRepo.create({
+                    code: dto.code,
+                    label: dto.label,
+                    description: dto.description ?? null,
+                    tableName,
+                    status: _enums_entity_status_enum_js__rspack_import_21/* .EntityStatus.ACTIVE */.c.ACTIVE,
+                    schemaVersion: 1,
+                    isSoftDeleteEnabled,
+                    isAuditEnabled,
+                    uiConfig: dto.uiConfig ?? null
+                }));
+                const fieldRepo = ctx.qr.manager.getRepository(_entities_field_definition_entity_js__rspack_import_5/* .FieldDefinition */.c);
+                if (fieldSpecs.length) {
+                    await fieldRepo.save(fieldSpecs.map((spec, index)=>fieldRepo.create({
+                            entityDefinitionId: definition.id,
+                            code: spec.code,
+                            label: spec.label,
+                            fieldType: spec.fieldType,
+                            dbType: this.dialectAdapter.mapFieldType(spec.fieldType, ctx.driver),
+                            nullable: spec.nullable ?? true,
+                            unique: spec.unique ?? false,
+                            isIndexed: spec.isIndexed ?? false,
+                            defaultValue: spec.defaultValue ?? null,
+                            validationRules: spec.validationRules ?? null,
+                            selectOptions: spec.selectOptions ?? null,
+                            relationTargetEntityId: spec.fieldType === _enums_field_type_enum_js__rspack_import_19/* .FieldType.RELATION */.P.RELATION ? spec.relationTargetEntityId : null,
+                            order: spec.order ?? index,
+                            uiConfig: spec.uiConfig ?? null,
+                            isSearchable: spec.isSearchable ?? false,
+                            isSystemField: false,
+                            deprecatedAt: null
+                        })));
+                }
+                created.definition = definition;
+            });
+            return {
+                operation: _enums_ddl_operation_enum_js__rspack_import_20/* .DdlOperation.CREATE_TABLE */.i.CREATE_TABLE,
+                entityDefinitionId: created.definition?.id ?? null,
+                diff: {
+                    fields: fieldSpecs.map((f)=>({
+                            code: f.code,
+                            fieldType: f.fieldType
+                        }))
+                },
+                bumpVersion: false,
+                afterCommit: async ()=>{
+                    if (!created.definition) return;
+                    try {
+                        await this.entityPermissionService.provisionForEntity(created.definition);
+                    } finally{
+                        if (flowEndpoints.length) created.warnings.push(...await this.createEndpointFlow(dto, flowEndpoints, user));
+                    }
+                }
+            };
+        };
+    }
+    /**
+   * The entity's ready-made flow, one Request step per requested endpoint, saved through
+   * FlowDefinitionService so it is validated like any other flow. The entity is already committed,
+   * so a flow that cannot be saved is reported as a warning.
+   */ async createEndpointFlow(dto, endpoints, user) {
+        const flow = (0,_entity_flow_scaffold_js__rspack_import_9/* .buildEntityFlow */.CO)({
+            code: dto.code,
+            label: dto.label,
+            fields: dto.fields ?? []
+        }, endpoints, dto.flowTexts);
+        try {
+            await this.flowDefinitionService.insert(flow, user);
+            return [];
+        } catch (error) {
+            this.logger.error(`The flow '${flow.slug}' of entity '${dto.code}' could not be created: ${error.message}`);
+            return [
+                (0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_17/* .SCHEMA_WARNING_MESSAGES.ENDPOINT_FLOW_FAILED */.Uu.ENDPOINT_FLOW_FAILED, {
+                    slug: flow.slug,
+                    detail: (0,_flow_engine_flow_errors_js__rspack_import_7/* .errorRef */.O$)(error)
+                })
+            ];
+        }
+    }
+    /** Preview of `createEntity`: the CREATE TABLE / CREATE INDEX statements, nothing is created. */ async planCreateEntity(dto, user) {
+        this.validateCreateRequest(dto);
+        return this.executor.simulate(await this.createTarget(dto, user), this.createRun(dto, user, {
+            warnings: []
+        }));
+    }
+    async createEntity(dto, user) {
+        this.validateCreateRequest(dto);
+        if (dto.flowEndpoints?.length) await this.flowDefinitionService.assertMayCreate(user);
+        const created = {
+            warnings: []
+        };
+        let planWarnings;
+        try {
+            ({ plan: { warnings: planWarnings } } = await this.executor.apply(await this.createTarget(dto, user), this.createRun(dto, user, created)));
+        } catch (error) {
+            if (error instanceof _nestjs_common__rspack_import_2.ConflictException && error.getResponse().blockers?.some((b)=>b.messageKey === _config_message_keys_js__rspack_import_17/* .SCHEMA_BLOCKER_MESSAGES.ENTITY_CODE_EXISTS */.M3.ENTITY_CODE_EXISTS || b.messageKey === _config_message_keys_js__rspack_import_17/* .SCHEMA_BLOCKER_MESSAGES.TABLE_EXISTS */.M3.TABLE_EXISTS)) {
+                throw new _nestjs_common__rspack_import_2.ConflictException({
+                    message: `An entity with the code '${dto.code}' already exists.`,
+                    messageKey: _config_message_keys_js__rspack_import_17/* .ENTITY_DEFINITION_MESSAGES.CODE_ALREADY_EXISTS */.pL.CODE_ALREADY_EXISTS,
+                    messageVariables: {
+                        code: dto.code
+                    }
+                });
+            }
+            throw error;
+        }
+        return {
+            definition: created.definition,
+            warnings: [
+                ...planWarnings,
+                ...created.warnings
+            ]
+        };
+    }
+}
+SchemaSyncService = _ts_decorate([
+    (0,_nestjs_common__rspack_import_2.Injectable)({
+        scope: _nestjs_common__rspack_import_2.Scope.REQUEST
+    }),
+    _ts_param(0, (0,_nestjs_common__rspack_import_2.Inject)(_entity_builder_datasource_provider_js__rspack_import_8/* .EntityBuilderDataSourceProvider */.D)),
+    _ts_param(1, (0,_nestjs_common__rspack_import_2.Inject)(_schema_dialect_adapter_service_js__rspack_import_16/* .SchemaDialectAdapterService */.I)),
+    _ts_param(2, (0,_nestjs_common__rspack_import_2.Inject)(_schema_change_executor_service_js__rspack_import_14/* .SchemaChangeExecutor */.T)),
+    _ts_param(3, (0,_nestjs_common__rspack_import_2.Inject)(_entity_permission_service_js__rspack_import_10/* .EntityPermissionService */.u)),
+    _ts_param(4, (0,_nestjs_common__rspack_import_2.Inject)(_flow_definition_service_js__rspack_import_12/* .FlowDefinitionService */.Tk)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _entity_builder_datasource_provider_js__rspack_import_8/* .EntityBuilderDataSourceProvider */.D === "undefined" ? Object : _entity_builder_datasource_provider_js__rspack_import_8/* .EntityBuilderDataSourceProvider */.D,
+        typeof _schema_dialect_adapter_service_js__rspack_import_16/* .SchemaDialectAdapterService */.I === "undefined" ? Object : _schema_dialect_adapter_service_js__rspack_import_16/* .SchemaDialectAdapterService */.I,
+        typeof _schema_change_executor_service_js__rspack_import_14/* .SchemaChangeExecutor */.T === "undefined" ? Object : _schema_change_executor_service_js__rspack_import_14/* .SchemaChangeExecutor */.T,
+        typeof _entity_permission_service_js__rspack_import_10/* .EntityPermissionService */.u === "undefined" ? Object : _entity_permission_service_js__rspack_import_10/* .EntityPermissionService */.u,
+        typeof _flow_definition_service_js__rspack_import_12/* .FlowDefinitionService */.Tk === "undefined" ? Object : _flow_definition_service_js__rspack_import_12/* .FlowDefinitionService */.Tk
+    ])
+], SchemaSyncService);
+
+__webpack_require__.d(__webpack_exports__, {
+  W: () => (SchemaSyncService)
+});
+
+
+},
+
+};