@flusys/nestjs-entity-builder 9.0.0

package/fesm/458.js

@@ -0,0 +1,649 @@
+export const __rspack_esm_id = 458;
+export const __rspack_esm_ids = [458];
+export const __webpack_modules__ = {
+4249(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  l: () => (/* reexport */ EntityBuilderModule)
+});
+
+// EXTERNAL MODULE: external "@flusys/nestjs-shared/modules"
+var modules_ = __webpack_require__(1236);
+// EXTERNAL MODULE: external "@nestjs/common"
+var common_ = __webpack_require__(6157);
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/config/entity-builder.constants.ts
+var entity_builder_constants = __webpack_require__(6576);
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/config/event-actions.ts
+var event_actions = __webpack_require__(982);
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/controllers/index.ts + 7 modules
+var controllers = __webpack_require__(6384);
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/interfaces/reference-provider.interface.ts
+var reference_provider_interface = __webpack_require__(2492);
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/rule-engine/index.ts + 1 modules
+var rule_engine = __webpack_require__(8429);
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/services/index.ts + 3 modules
+var services = __webpack_require__(8752);
+;// CONCATENATED MODULE: ./projects/nestjs-entity-builder/src/modules/entity-builder.module.ts
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
+        r = Reflect.decorate(decorators, target, key, desc);
+    } else {
+        for(var i = decorators.length - 1; i >= 0; i--){
+            if (d = decorators[i]) {
+                r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+            }
+        }
+    }
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+
+
+
+
+
+
+
+class EntityBuilderModule {
+    static CONTROLLERS = [
+        controllers/* .EntityDefinitionController */.hv,
+        controllers/* .FieldDefinitionController */.GX,
+        controllers/* .FlowDefinitionController */.W8,
+        controllers/* .FlowExecutionController */.VU,
+        controllers/* .FlowRuntimeController */.bw
+    ];
+    static EXPORTS = [
+        services/* .EntityBuilderConfigService */.E,
+        services/* .EntityBuilderDataSourceProvider */.DR,
+        services/* .SchemaDialectAdapterService */.Io,
+        services/* .SchemaRegistryService */.Cy,
+        services/* .SchemaSyncService */.WQ,
+        services/* .DefinitionCacheService */.Vo,
+        services/* .SchemaChangeExecutor */.TQ,
+        services/* .SchemaEvolutionService */._X,
+        services/* .ReferenceScannerService */.tH,
+        services/* .EntityDefinitionService */.oc,
+        services/* .FieldDefinitionService */.J,
+        services/* .GenericEntityServiceFactory */.GR,
+        services/* .EntityPermissionService */.u4,
+        rule_engine/* .RuleEngineService */.iI,
+        services/* .FlowDefinitionService */.Tk,
+        services/* .FlowExecutorService */.FT,
+        services/* .FlowRuntimeService */.a$
+    ];
+    static forRoot(options) {
+        return {
+            module: EntityBuilderModule,
+            global: options.global ?? false,
+            imports: [
+                modules_.CacheModule,
+                modules_.UtilsModule
+            ],
+            controllers: options.includeController !== false ? this.CONTROLLERS : [],
+            providers: [
+                ...this.buildProviders(options),
+                ...options.providers ?? []
+            ],
+            exports: this.EXPORTS
+        };
+    }
+    static forRootAsync(options) {
+        return {
+            module: EntityBuilderModule,
+            global: options.global ?? false,
+            imports: [
+                ...options.imports || [],
+                modules_.CacheModule,
+                modules_.UtilsModule
+            ],
+            controllers: options.includeController !== false ? this.CONTROLLERS : [],
+            providers: [
+                ...this.buildAsyncProviders(options),
+                ...this.buildProviders(),
+                ...options.providers ?? []
+            ],
+            exports: this.EXPORTS
+        };
+    }
+    static buildProviders(options) {
+        const providers = [
+            services/* .EntityBuilderConfigService */.E,
+            services/* .EntityBuilderDataSourceProvider */.DR,
+            services/* .SchemaDialectAdapterService */.Io,
+            services/* .SchemaRegistryService */.Cy,
+            services/* .SchemaSyncService */.WQ,
+            services/* .DefinitionCacheService */.Vo,
+            services/* .SchemaChangeExecutor */.TQ,
+            services/* .SchemaEvolutionService */._X,
+            services/* .ReferenceScannerService */.tH,
+            services/* .EntityDefinitionService */.oc,
+            services/* .FieldDefinitionService */.J,
+            services/* .GenericEntityServiceFactory */.GR,
+            services/* .EntityPermissionService */.u4,
+            rule_engine/* .RuleEngineService */.iI,
+            services/* .FlowDefinitionService */.Tk,
+            services/* .FlowExecutionService */.AJ,
+            services/* .FlowExecutorService */.FT,
+            services/* .FlowRuntimeService */.a$,
+            services/* .FlowReferenceProvider */.Ly,
+            {
+                provide: reference_provider_interface/* .FLOW_REFERENCE_PROVIDER */.$,
+                useExisting: services/* .FlowReferenceProvider */.Ly
+            }
+        ];
+        if (options) {
+            providers.unshift({
+                provide: entity_builder_constants/* .ENTITY_BUILDER_MODULE_OPTIONS */.CP,
+                useValue: options
+            });
+        }
+        providers.push((0,modules_.createModuleEventsProvider)(event_actions/* .ENTITY_BUILDER_EVENT_MODULE */.S, entity_builder_constants/* .ENTITY_BUILDER_MODULE_OPTIONS */.CP));
+        return providers;
+    }
+    static buildAsyncProviders(options) {
+        if (options.useFactory) {
+            return [
+                {
+                    provide: entity_builder_constants/* .ENTITY_BUILDER_MODULE_OPTIONS */.CP,
+                    useFactory: async (...args)=>({
+                            ...options,
+                            config: await options.useFactory(...args)
+                        }),
+                    inject: options.inject || []
+                }
+            ];
+        }
+        const factoryClass = options.useClass || options.useExisting;
+        if (!factoryClass) {
+            if (!options.config) {
+                throw new Error('EntityBuilderModule.forRootAsync() needs useFactory, useClass, useExisting or a static config.');
+            }
+            return [
+                {
+                    provide: entity_builder_constants/* .ENTITY_BUILDER_MODULE_OPTIONS */.CP,
+                    useValue: {
+                        ...options
+                    }
+                }
+            ];
+        }
+        const providers = [
+            {
+                provide: entity_builder_constants/* .ENTITY_BUILDER_MODULE_OPTIONS */.CP,
+                useFactory: async (factory)=>({
+                        ...options,
+                        config: await factory.createEntityBuilderOptions()
+                    }),
+                inject: [
+                    factoryClass
+                ]
+            }
+        ];
+        if (options.useClass) {
+            providers.push({
+                provide: options.useClass,
+                useClass: options.useClass
+            });
+        }
+        return providers;
+    }
+}
+EntityBuilderModule = _ts_decorate([
+    (0,common_.Module)({})
+], EntityBuilderModule);
+
+;// CONCATENATED MODULE: ./projects/nestjs-entity-builder/src/modules/index.ts
+
+
+
+},
+8752(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  zb: () => (/* reexport */ generic_entity_service/* .ACTOR_BRANCH_METADATA_KEY */.zb),
+  Fz: () => (/* reexport */ (/* inlined export .DRAFT_TEST_RETAIN */200)),
+  Vo: () => (/* reexport */ definition_cache_service/* .DefinitionCacheService */.V),
+  IP: () => (/* reexport */ entity_flow_scaffold/* .ENTITY_FLOW_PATHS */.IP),
+  E: () => (/* reexport */ entity_builder_config_service/* .EntityBuilderConfigService */.E),
+  DR: () => (/* reexport */ entity_builder_datasource_provider/* .EntityBuilderDataSourceProvider */.D),
+  oc: () => (/* reexport */ entity_definition_service/* .EntityDefinitionService */.o),
+  u4: () => (/* reexport */ entity_permission_service/* .EntityPermissionService */.u),
+  J: () => (/* reexport */ field_definition_service/* .FieldDefinitionService */.J),
+  Tk: () => (/* reexport */ flow_definition_service/* .FlowDefinitionService */.Tk),
+  AJ: () => (/* reexport */ flow_execution_service/* .FlowExecutionService */.A),
+  FT: () => (/* reexport */ flow_executor_service/* .FlowExecutorService */.F),
+  Ly: () => (/* reexport */ FlowReferenceProvider),
+  a$: () => (/* reexport */ flow_runtime_service/* .FlowRuntimeService */.a),
+  GK: () => (/* reexport */ generic_entity_service/* .GenericEntityService */.GK),
+  GR: () => (/* reexport */ generic_entity_service_factory/* .GenericEntityServiceFactory */.G),
+  gW: () => (/* reexport */ schema_columns/* .NON_INDEXABLE_FIELD_TYPES */.gW),
+  xJ: () => (/* reexport */ identifier_rules/* .RESERVED_WORDS */.xJ),
+  tH: () => (/* reexport */ reference_scanner_service/* .ReferenceScannerService */.t),
+  mq: () => (/* reexport */ schema_columns/* .SYSTEM_COLUMN_NAMES */.mq),
+  TQ: () => (/* reexport */ schema_change_executor_service/* .SchemaChangeExecutor */.T),
+  Io: () => (/* reexport */ schema_dialect_adapter_service/* .SchemaDialectAdapterService */.I),
+  _X: () => (/* reexport */ schema_evolution_service/* .SchemaEvolutionService */._),
+  Cy: () => (/* reexport */ schema_registry_service/* .SchemaRegistryService */.C),
+  WQ: () => (/* reexport */ schema_sync_service/* .SchemaSyncService */.W),
+  DG: () => (/* reexport */ generic_entity_service/* .actorMetadata */.DG),
+  $6: () => (/* reexport */ schema_columns/* .addUnique */.$6),
+  fY: () => (/* reexport */ identifier_rules/* .assertIndexableField */.fY),
+  kV: () => (/* reexport */ identifier_rules/* .assertValidIdentifier */.kV),
+  HK: () => (/* reexport */ schema_columns/* .auditColumns */.HK),
+  CO: () => (/* reexport */ entity_flow_scaffold/* .buildEntityFlow */.CO),
+  fu: () => (/* reexport */ schema_columns/* .buildFieldColumn */.fu),
+  Rm: () => (/* reexport */ schema_columns/* .buildSystemColumns */.Rm),
+  Er: () => (/* reexport */ flow_definition_service/* .defaultFlowPermissionCode */.Er),
+  an: () => (/* reexport */ schema_change_types/* .describeImpact */.a),
+  x2: () => (/* reexport */ entity_flow_scaffold/* .entityFlowSlug */.x2),
+  HQ: () => (/* reexport */ schema_dialect_adapter_service/* .fitIdentifier */.H),
+  YW: () => (/* reexport */ flow_definition_service/* .flowNotFound */.YW),
+  gl: () => (/* reexport */ flow_executor_service/* .flowTimeout */.g),
+  mo: () => (/* reexport */ schema_columns/* .indexName */.mo),
+  C5: () => (/* reexport */ schema_evolution_service/* .isDestructiveSchemaAction */.C),
+  d4: () => (/* reexport */ schema_columns/* .isIndexableFieldType */.d4),
+  HF: () => (/* reexport */ flow_definition_service/* .isPublished */.HF),
+  Eq: () => (/* reexport */ database_error_mapper/* .mapDatabaseError */.E),
+  iw: () => (/* reexport */ database_error_mapper/* .mapSchemaError */.i),
+  v7: () => (/* reexport */ schema_columns/* .plainIndex */.v7),
+  IM: () => (/* reexport */ field_type_conversion/* .planTypeConversion */.I),
+  e1: () => (/* reexport */ schema_change_executor_service/* .relationTargetCodes */.e),
+  Sd: () => (/* reexport */ flow_runtime_service/* .requestInfo */.S),
+  G7: () => (/* reexport */ schema_columns/* .sameColumns */.G7),
+  eY: () => (/* reexport */ flow_definition_service/* .snapshotOf */.eY),
+  OG: () => (/* reexport */ schema_columns/* .softDeleteColumn */.OG),
+  cg: () => (/* reexport */ schema_columns/* .sqlTypeFor */.cg),
+  uy: () => (/* reexport */ schema_columns/* .tableUnique */.uy),
+  RK: () => (/* reexport */ flow_definition_service/* .toFlowSettings */.RK),
+  jp: () => (/* reexport */ schema_columns/* .typeFamily */.jp),
+  eV: () => (/* reexport */ field_value_validator/* .validateRecord */.e),
+  lw: () => (/* reexport */ flow_definition_service/* .workingCopy */.lw)
+});
+
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/services/entity-builder-config.service.ts
+var entity_builder_config_service = __webpack_require__(4281);
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/services/entity-builder-datasource.provider.ts
+var entity_builder_datasource_provider = __webpack_require__(424);
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/services/schema-dialect-adapter.service.ts
+var schema_dialect_adapter_service = __webpack_require__(7259);
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/services/schema-registry.service.ts
+var schema_registry_service = __webpack_require__(2134);
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/services/schema-sync.service.ts
+var schema_sync_service = __webpack_require__(3474);
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/services/entity-definition.service.ts
+var entity_definition_service = __webpack_require__(1296);
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/services/field-definition.service.ts
+var field_definition_service = __webpack_require__(9487);
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/services/generic-entity.service.ts
+var generic_entity_service = __webpack_require__(3998);
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/services/generic-entity-service.factory.ts
+var generic_entity_service_factory = __webpack_require__(7705);
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/services/entity-permission.service.ts
+var entity_permission_service = __webpack_require__(1462);
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/services/definition-cache.service.ts
+var definition_cache_service = __webpack_require__(2931);
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/services/schema-change-executor.service.ts
+var schema_change_executor_service = __webpack_require__(6605);
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/services/schema-change.types.ts
+var schema_change_types = __webpack_require__(7827);
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/services/schema-columns.ts
+var schema_columns = __webpack_require__(5313);
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/services/field-type-conversion.ts
+var field_type_conversion = __webpack_require__(4984);
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/services/identifier-rules.ts
+var identifier_rules = __webpack_require__(413);
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/services/schema-evolution.service.ts
+var schema_evolution_service = __webpack_require__(3606);
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/services/reference-scanner.service.ts
+var reference_scanner_service = __webpack_require__(921);
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/services/field-value-validator.ts
+var field_value_validator = __webpack_require__(3525);
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/services/database-error.mapper.ts
+var database_error_mapper = __webpack_require__(8323);
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/services/flow-definition.service.ts + 1 modules
+var flow_definition_service = __webpack_require__(4921);
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/services/flow-execution.service.ts
+var flow_execution_service = __webpack_require__(7810);
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/services/flow-executor.service.ts + 5 modules
+var flow_executor_service = __webpack_require__(4698);
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/services/flow-runtime.service.ts
+var flow_runtime_service = __webpack_require__(2300);
+// EXTERNAL MODULE: external "@flusys/nestjs-shared/utils"
+var utils_ = __webpack_require__(9216);
+// EXTERNAL MODULE: external "@nestjs/common"
+var common_ = __webpack_require__(6157);
+// EXTERNAL MODULE: external "typeorm"
+var external_typeorm_ = __webpack_require__(7158);
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/config/message-keys.ts
+var message_keys = __webpack_require__(5732);
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/entities/flow-definition.entity.ts
+var flow_definition_entity = __webpack_require__(3770);
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/entities/flow-version.entity.ts
+var flow_version_entity = __webpack_require__(2399);
+;// CONCATENATED MODULE: ./projects/nestjs-entity-builder/src/services/reference-rewrite.ts
+/** Pure JSON string helpers for finding and rewriting `<prefix>.<field>` references inside definitions. */ function mapStrings(value, fn) {
+    if (typeof value === 'string') return fn(value);
+    if (Array.isArray(value)) return value.map((v)=>mapStrings(v, fn));
+    if (value && typeof value === 'object') {
+        return Object.fromEntries(Object.entries(value).map(([k, v])=>[
+                k,
+                mapStrings(v, fn)
+            ]));
+    }
+    return value;
+}
+function anyString(value, test) {
+    if (typeof value === 'string') return test(value);
+    if (Array.isArray(value)) return value.some((v)=>anyString(v, test));
+    if (value && typeof value === 'object') return Object.values(value).some((v)=>anyString(v, test));
+    return false;
+}
+const escapeRe = (s)=>s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+/**
+ * `<prefix>.<field>`, `<prefix>.<field>.x` or `{{ <prefix>.<field> }}` inside a template - but not
+ * `<prefix>.<field>_2`. The prefix is a regex source (e.g. `context\.find\.items\.\d+`), captured so a rewrite keeps it.
+ */ const referencePatternSource = (prefixSource, field, flags = '')=>new RegExp(`(^|\\{\\{\\s*)(${prefixSource})\\.${escapeRe(field)}(?!\\w)`, flags);
+const replaceReferenceSource = (s, prefixSource, from, to)=>s.replace(referencePatternSource(prefixSource, from, 'g'), (_match, lead, prefix)=>`${lead}${prefix}.${to}`);
+
+;// CONCATENATED MODULE: ./projects/nestjs-entity-builder/src/flow-engine/flow-reference.ts
+
+const entityOf = (node)=>node.config?.entityCode;
+const childrenOf = (node)=>{
+    if (node.type !== 'entity_insert') return [];
+    const children = node.config?.children;
+    return Array.isArray(children) ? children.filter((c)=>!!c && typeof c === 'object') : [];
+};
+const isLookupOn = (value, entityCode)=>!!value && typeof value === 'object' && !Array.isArray(value) && value.type === 'lookup' && value.entity === entityCode;
+function anyLookup(value, entityCode, test) {
+    if (Array.isArray(value)) return value.some((v)=>anyLookup(v, entityCode, test));
+    if (!value || typeof value !== 'object') return false;
+    if (isLookupOn(value, entityCode) && test(value)) return true;
+    return Object.values(value).some((v)=>anyLookup(v, entityCode, test));
+}
+function mapLookups(value, entityCode, fn) {
+    if (Array.isArray(value)) return value.map((v)=>mapLookups(v, entityCode, fn));
+    if (!value || typeof value !== 'object') return value;
+    const mapped = Object.fromEntries(Object.entries(value).map(([k, v])=>[
+            k,
+            mapLookups(v, entityCode, fn)
+        ]));
+    return isLookupOn(mapped, entityCode) ? fn(mapped) : mapped;
+}
+const lookupUsesField = (lookup, field)=>lookup.field === field || lookup.sort?.field === field || !!lookup.filter && field in lookup.filter;
+const childUsesField = (child, field)=>child.parentField === field || !!child.fields && typeof child.fields === 'object' && field in child.fields;
+function flowUsesEntity(nodes, entityCode) {
+    return nodes.some((n)=>entityOf(n) === entityCode || childrenOf(n).some((c)=>c.entityCode === entityCode) || anyLookup(n.config, entityCode, ()=>true));
+}
+const ITEM = '\\.items\\.\\d+';
+/** Regex sources of every output path that holds a record of the entity. */ function recordPrefixes(nodes, entityCode) {
+    const out = [];
+    for (const node of nodes){
+        const base = `context\\.${escapeRe(node.id)}`;
+        if (entityOf(node) === entityCode) {
+            if (node.type === 'entity_get') out.push(base);
+            else if (node.type === 'entity_insert' || node.type === 'entity_update') out.push(`${base}(?:${ITEM})?`);
+            else if (node.type === 'entity_query') out.push(`${base}${ITEM}`);
+        }
+        for (const child of childrenOf(node)){
+            if (child.entityCode === entityCode && typeof child.as === 'string' && child.as) out.push(`${base}(?:${ITEM})?\\.${escapeRe(child.as)}\\.\\d+`);
+        }
+    }
+    return out;
+}
+function flowRefersToField(nodes, entityCode, field) {
+    const patterns = recordPrefixes(nodes, entityCode).map((prefix)=>referencePatternSource(prefix, field));
+    return nodes.some((node)=>{
+        if (entityOf(node) === entityCode) {
+            const c = node.config;
+            if (c.fields && field in c.fields) return true;
+            if (c.filter && field in c.filter) return true;
+            if (c.sort?.field === field) return true;
+        }
+        if (childrenOf(node).some((child)=>child.entityCode === entityCode && childUsesField(child, field))) return true;
+        if (anyLookup(node.config, entityCode, (lookup)=>lookupUsesField(lookup, field))) return true;
+        return patterns.length > 0 && anyString(node.config, (s)=>patterns.some((p)=>p.test(s)));
+    });
+}
+function rewriteFlowField(nodes, entityCode, from, to) {
+    const prefixes = recordPrefixes(nodes, entityCode);
+    let changed = false;
+    const renameKey = (map)=>{
+        if (!map || !(from in map)) return map;
+        changed = true;
+        return Object.fromEntries(Object.entries(map).map(([k, v])=>[
+                k === from ? to : k,
+                v
+            ]));
+    };
+    const renameChild = (child)=>{
+        if (child.entityCode !== entityCode || !childUsesField(child, from)) return child;
+        changed = true;
+        return {
+            ...child,
+            ...child.fields && from in child.fields ? {
+                fields: renameKey(child.fields)
+            } : {},
+            ...child.parentField === from ? {
+                parentField: to
+            } : {}
+        };
+    };
+    const rewritten = nodes.map((node)=>{
+        let config = node.config;
+        if (entityOf(node) === entityCode) {
+            const next = {
+                ...config
+            };
+            if (next['fields']) next['fields'] = renameKey(next['fields']);
+            if (next['filter']) next['filter'] = renameKey(next['filter']);
+            const sort = next['sort'];
+            if (sort?.field === from) {
+                next['sort'] = {
+                    ...sort,
+                    field: to
+                };
+                changed = true;
+            }
+            config = next;
+        }
+        const children = childrenOf(node);
+        if (children.some((child)=>child.entityCode === entityCode && childUsesField(child, from))) {
+            config = {
+                ...config,
+                children: children.map(renameChild)
+            };
+        }
+        config = mapLookups(config, entityCode, (lookup)=>{
+            if (!lookupUsesField(lookup, from)) return lookup;
+            changed = true;
+            return {
+                ...lookup,
+                ...lookup.filter ? {
+                    filter: renameKey(lookup.filter)
+                } : {},
+                ...lookup.field === from ? {
+                    field: to
+                } : {},
+                ...lookup.sort?.field === from ? {
+                    sort: {
+                        ...lookup.sort,
+                        field: to
+                    }
+                } : {}
+            };
+        });
+        if (prefixes.length) {
+            config = mapStrings(config, (s)=>{
+                const out = prefixes.reduce((acc, prefix)=>replaceReferenceSource(acc, prefix, from, to), s);
+                if (out !== s) changed = true;
+                return out;
+            });
+        }
+        return config === node.config ? node : {
+            ...node,
+            config
+        };
+    });
+    return {
+        nodes: rewritten,
+        changed
+    };
+}
+
+;// CONCATENATED MODULE: ./projects/nestjs-entity-builder/src/services/flow-reference.provider.ts
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
+        r = Reflect.decorate(decorators, target, key, desc);
+    } else {
+        for(var i = decorators.length - 1; i >= 0; i--){
+            if (d = decorators[i]) {
+                r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+            }
+        }
+    }
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+        return Reflect.metadata(metadataKey, metadataValue);
+    }
+}
+function _ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+
+
+
+
+
+
+
+
+class FlowReferenceProvider {
+    provider;
+    constructor(provider){
+        this.provider = provider;
+    }
+    async flows() {
+        return (await this.repo(flow_definition_entity/* .FlowDefinition */.G)).find({
+            where: {
+                deletedAt: (0,external_typeorm_.IsNull)()
+            }
+        });
+    }
+    async repo(entity, manager) {
+        return manager ? manager.getRepository(entity) : this.provider.getRepository(entity);
+    }
+    async findEntityReferences(entityCode) {
+        return (await this.flows()).filter((f)=>flowUsesEntity(f.nodes, entityCode) || !!f.draft && flowUsesEntity(f.draft.nodes, entityCode)).map((f)=>({
+                kind: 'flow',
+                id: f.id,
+                name: f.name,
+                detail: (0,utils_.messageRef)(message_keys/* .SCHEMA_IMPACT_MESSAGES.FLOW_ON_ENTITY */.aB.FLOW_ON_ENTITY, {
+                    slug: f.slug
+                })
+            }));
+    }
+    async findFieldReferences(entityCode, fieldCode) {
+        return (await this.flows()).filter((f)=>flowRefersToField(f.nodes, entityCode, fieldCode) || !!f.draft && flowRefersToField(f.draft.nodes, entityCode, fieldCode)).map((f)=>({
+                kind: 'flow',
+                id: f.id,
+                name: f.name,
+                detail: (0,utils_.messageRef)(message_keys/* .SCHEMA_IMPACT_MESSAGES.FLOW_USES_FIELD */.aB.FLOW_USES_FIELD, {
+                    slug: f.slug,
+                    field: fieldCode
+                })
+            }));
+    }
+    async rewriteFieldReferences(entityCode, from, to, manager) {
+        let count = 0;
+        const flows = await this.repo(flow_definition_entity/* .FlowDefinition */.G, manager);
+        // Deleted flows too: one restored later must not bring the old field name back.
+        for (const flow of (await flows.find({
+            withDeleted: true
+        }))){
+            // The published flow and its unpublished draft both keep working after the rename.
+            const live = rewriteFlowField(flow.nodes, entityCode, from, to);
+            const draft = flow.draft ? rewriteFlowField(flow.draft.nodes, entityCode, from, to) : null;
+            if (!live.changed && !draft?.changed) continue;
+            await flows.update(flow.id, {
+                nodes: live.nodes,
+                ...draft?.changed ? {
+                    draft: {
+                        ...flow.draft,
+                        nodes: draft.nodes
+                    }
+                } : {}
+            });
+            count++;
+        }
+        // A version restored later must not bring the old field name back.
+        const versions = await this.repo(flow_version_entity/* .FlowVersion */.p, manager);
+        for (const version of (await versions.find({
+            select: {
+                id: true,
+                definition: true
+            }
+        }))){
+            const { nodes, changed } = rewriteFlowField(version.definition.nodes, entityCode, from, to);
+            if (changed) await versions.update(version.id, {
+                definition: {
+                    ...version.definition,
+                    nodes
+                }
+            });
+        }
+        return count;
+    }
+}
+FlowReferenceProvider = _ts_decorate([
+    (0,common_.Injectable)({
+        scope: common_.Scope.REQUEST
+    }),
+    _ts_param(0, (0,common_.Inject)(entity_builder_datasource_provider/* .EntityBuilderDataSourceProvider */.D)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof entity_builder_datasource_provider/* .EntityBuilderDataSourceProvider */.D === "undefined" ? Object : entity_builder_datasource_provider/* .EntityBuilderDataSourceProvider */.D
+    ])
+], FlowReferenceProvider);
+
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/services/entity-flow-scaffold.ts
+var entity_flow_scaffold = __webpack_require__(8271);
+;// CONCATENATED MODULE: ./projects/nestjs-entity-builder/src/services/index.ts
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+},
+
+};