@acorex-platform/module-platform-management-client 0.0.21

package/fesm2022/acorex-platform-module-platform-management-client-create-user-query.command-2Qu7aoCp.mjs

@@ -0,0 +1,1542 @@
+import { resolveLayoutBuilderDialogResult, AXPLayoutBuilderService } from '@acorex-platform/framework-client/layout/builder';
+import { AXPEntityResolver } from '@acorex-platform/framework-client/layout/entity';
+import { resolveEntityActionCommandInput, entityActionDataRecord } from '@acorex-platform/framework-shared/runtime';
+import { AXToastService } from '@acorex/components/toast';
+import { AXTranslationService } from '@acorex/core/translation';
+import * as i0 from '@angular/core';
+import { inject, Injectable } from '@angular/core';
+import { AXPWidgetsList } from '@acorex-platform/framework-shared/core';
+import { parsePropertyExposeEntries } from '@acorex-platform/framework-shared/entity';
+import { C as CREATE_USER_QUERY_I18N, a as CREATE_USER_QUERY_WIZARD_NAME, b as CREATE_USER_QUERY_ENTITY_CATALOG } from './acorex-platform-module-platform-management-client-create-user-query.types-DdygAori.mjs';
+import { n as normalizeRestApiOutput, c as createEmptyRestApiOutput, R as REST_API_GENERATOR_WIDGET_NAME } from './acorex-platform-module-platform-management-client-acorex-platform-module-platform-management-client-V_ao4WVM.mjs';
+
+//#region ----- Imports -----
+//#endregion
+//#region ----- Constants -----
+const LOOKUP_WIDGET_TYPES = new Set(['lookup-editor', 'select-editor']);
+const USER_QUERY_RELATED_DEPTH = 3;
+//#endregion
+//#region ----- Public API -----
+function parseEntityFullName(fullName) {
+    const trimmed = fullName.trim();
+    const separator = trimmed.indexOf('.');
+    if (separator <= 0 || separator === trimmed.length - 1) {
+        return null;
+    }
+    return {
+        module: trimmed.slice(0, separator),
+        name: trimmed.slice(separator + 1),
+    };
+}
+function resolvePickedEntityFullName(value) {
+    if (typeof value === 'string') {
+        return value.trim();
+    }
+    if (value == null || typeof value !== 'object') {
+        return '';
+    }
+    const record = value;
+    const id = typeof record['id'] === 'string' ? record['id'].trim() : '';
+    if (id.includes('.')) {
+        return id;
+    }
+    const moduleName = typeof record['module_id'] === 'string' ? record['module_id'].trim() : '';
+    const name = typeof record['name'] === 'string' ? record['name'].trim() : '';
+    if (moduleName && name) {
+        return `${moduleName}.${name}`;
+    }
+    return id;
+}
+function collectUserQueryEntityFieldGroups(entity, relatedByName) {
+    return collectGroups(entity, relatedByName, '', new Set());
+}
+function flattenEntityFieldGroups(groups) {
+    const result = [];
+    const walk = (group) => {
+        result.push(group);
+        for (const child of group.children ?? []) {
+            walk(child);
+        }
+    };
+    for (const group of groups) {
+        walk(group);
+    }
+    return result;
+}
+function defaultSelectedFieldGroups(groups) {
+    const selected = {};
+    for (const group of flattenEntityFieldGroups(groups)) {
+        selected[group.id] = [];
+    }
+    for (const group of groups) {
+        if (group.kind !== 'relation') {
+            selected[group.id] = group.items.map((item) => item.path);
+        }
+    }
+    return selected;
+}
+function collectSelectedFieldGroupPaths(fieldGroups, groups) {
+    const paths = [];
+    const walk = (group) => {
+        paths.push(...normalizeSelectedFieldPaths(fieldGroups?.[group.id]));
+        for (const child of group.children ?? []) {
+            walk(child);
+        }
+    };
+    for (const group of groups) {
+        walk(group);
+    }
+    return paths;
+}
+function withRequiredIdField(paths) {
+    const unique = [];
+    const seen = new Set();
+    for (const path of paths) {
+        const trimmed = path.trim();
+        if (!trimmed || seen.has(trimmed)) {
+            continue;
+        }
+        seen.add(trimmed);
+        unique.push(trimmed);
+    }
+    if (!seen.has('id')) {
+        unique.unshift('id');
+    }
+    return unique;
+}
+function normalizeSelectedFieldPaths(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    const paths = [];
+    for (const item of value) {
+        if (typeof item === 'string') {
+            paths.push(item);
+            continue;
+        }
+        if (item != null && typeof item === 'object') {
+            const path = item.path;
+            if (typeof path === 'string') {
+                paths.push(path);
+            }
+        }
+    }
+    return paths;
+}
+//#endregion
+//#region ----- Group collection -----
+function collectGroups(entity, relatedByName, pathPrefix, ancestry) {
+    const groups = [];
+    const { host, lookups } = collectHostAndLookups(entity, pathPrefix);
+    if (host.items.length) {
+        groups.push(host);
+    }
+    groups.push(...lookups);
+    const hostFullName = `${entity.module}.${entity.name}`;
+    const nextAncestry = new Set(ancestry);
+    nextAncestry.add(hostFullName);
+    for (const related of entity.relatedEntities ?? []) {
+        const group = collectRelatedGroup(related, relatedByName, pathPrefix, nextAncestry);
+        if (group) {
+            groups.push(group);
+        }
+    }
+    return groups;
+}
+function collectHostAndLookups(entity, pathPrefix, allowedNames) {
+    const hostItems = [];
+    const lookups = [];
+    for (const property of entity?.properties ?? []) {
+        const name = property.name?.trim();
+        if (!name || name.toLowerCase() === 'id') {
+            continue;
+        }
+        if (allowedNames && !allowedNames.has(name)) {
+            continue;
+        }
+        if (isLookupProperty(property)) {
+            const lookupGroup = collectLookupGroup(property, pathPrefix);
+            if (lookupGroup) {
+                lookups.push(lookupGroup);
+            }
+            continue;
+        }
+        hostItems.push({
+            path: joinPath(pathPrefix, name),
+            title: property.title,
+            fallback: name,
+        });
+    }
+    return {
+        host: {
+            id: pathPrefix ? `rel_${sanitizeGroupId(pathPrefix)}_fields` : 'host',
+            kind: pathPrefix ? 'relation' : 'host',
+            title: '',
+            fallback: 'fields',
+            items: hostItems,
+        },
+        lookups,
+    };
+}
+function collectLookupGroup(property, pathPrefix) {
+    const name = property.name?.trim();
+    if (!name) {
+        return null;
+    }
+    const items = [
+        {
+            path: joinPath(pathPrefix, name),
+            title: property.title,
+            fallback: name,
+        },
+    ];
+    const opts = property.schema?.interface?.options;
+    for (const entry of parsePropertyExposeEntries(opts)) {
+        const target = entry.target.trim();
+        if (!target || target === name) {
+            continue;
+        }
+        items.push({
+            path: joinPath(pathPrefix, target),
+            title: entry.source,
+            fallback: entry.source.trim() || target,
+        });
+    }
+    return {
+        id: `lookup_${sanitizeGroupId(joinPath(pathPrefix, name))}`,
+        kind: 'lookup',
+        title: property.title,
+        fallback: name,
+        items,
+    };
+}
+function collectRelatedGroup(related, relatedByName, pathPrefix, ancestry) {
+    if (related.hidden === true) {
+        return null;
+    }
+    const entityName = related.entity?.trim();
+    if (!entityName || ancestry.has(entityName)) {
+        return null;
+    }
+    const relatedEntity = relatedByName.get(entityName);
+    const dataPath = related.persistence?.dataPath?.trim() || entityName.split('.').pop() || entityName;
+    const pathRoot = joinPath(pathPrefix, dataPath);
+    const allowed = resolveAllowedPropertyNames(related, relatedEntity);
+    const { host, lookups } = collectHostAndLookups(relatedEntity, pathRoot, allowed);
+    const childAncestry = new Set(ancestry);
+    childAncestry.add(entityName);
+    const children = [...lookups];
+    for (const nested of relatedEntity?.relatedEntities ?? []) {
+        const child = collectRelatedGroup(nested, relatedByName, pathRoot, childAncestry);
+        if (child) {
+            children.push(child);
+        }
+    }
+    if (!host.items.length && !children.length) {
+        return null;
+    }
+    return {
+        id: `rel_${sanitizeGroupId(pathRoot)}`,
+        kind: 'relation',
+        title: related.title,
+        fallback: entityName,
+        items: host.items,
+        children: children.length ? children : undefined,
+    };
+}
+function resolveAllowedPropertyNames(related, relatedEntity) {
+    const excluded = new Set((related.excludeProperties ?? [])
+        .filter((name) => typeof name === 'string')
+        .map((name) => name.trim())
+        .filter(Boolean));
+    const fromConfig = Array.isArray(related.properties)
+        ? related.properties.filter((name) => typeof name === 'string' && name.trim().length > 0)
+        : [];
+    if (fromConfig.length) {
+        return new Set(fromConfig.map((name) => name.trim()).filter((name) => name.toLowerCase() !== 'id' && !excluded.has(name)));
+    }
+    if (!excluded.size) {
+        return undefined;
+    }
+    const names = (relatedEntity?.properties ?? [])
+        .map((property) => property.name?.trim() ?? '')
+        .filter((name) => name && name.toLowerCase() !== 'id' && !excluded.has(name));
+    return new Set(names);
+}
+function isLookupProperty(property) {
+    const iface = property.schema?.interface;
+    const opts = iface?.options;
+    const lookupEntity = typeof opts?.['entity'] === 'string' ? String(opts['entity']).trim() : '';
+    if (!lookupEntity) {
+        return false;
+    }
+    const widgetType = typeof iface?.type === 'string' ? iface.type : '';
+    if (LOOKUP_WIDGET_TYPES.has(widgetType)) {
+        return true;
+    }
+    return /(Ids|IDs|Id|ID)$/i.test(property.name);
+}
+function joinPath(prefix, segment) {
+    return prefix ? `${prefix}.${segment}` : segment;
+}
+function sanitizeGroupId(value) {
+    return value.replace(/[^a-zA-Z0-9]+/g, '_').replace(/^_|_$/g, '');
+}
+//#endregion
+
+//#region ----- Imports -----
+const ENTITY_WIZARD_BACK = 'back';
+const API_WIZARD_BACK = 'back';
+//#endregion
+//#region ----- Public API -----
+async function openCreateUserQueryWizard(args) {
+    if (args.sourceKind === 'advanced') {
+        return openAdvancedPlaceholder(args);
+    }
+    if (args.sourceKind === 'entity') {
+        return openEntitySourceWizard(args);
+    }
+    if (args.sourceKind === 'api') {
+        return openApiSourceWizard(args);
+    }
+    const result = await args.layoutBuilder
+        .create()
+        .dialog((dialog) => {
+        configureSimpleSourceWizard(dialog, args);
+    })
+        .show();
+    return resolveLayoutBuilderDialogResult(result);
+}
+//#endregion
+//#region ----- Entity sub-steps -----
+async function openEntitySourceWizard(args) {
+    let entityName = '';
+    let previousFields;
+    while (true) {
+        const picked = await openEntityPickDialog(args, entityName);
+        if (!picked) {
+            return null;
+        }
+        const graph = await loadEntityFieldGraph(args, picked);
+        if (!graph) {
+            entityName = picked;
+            continue;
+        }
+        const selectedGroups = picked === entityName && previousFields != null ? previousFields : graph.defaultGroups;
+        const outcome = await openEntityFieldsDialog(args, picked, graph.groups, selectedGroups);
+        if (outcome === ENTITY_WIZARD_BACK) {
+            entityName = picked;
+            previousFields = selectedGroups;
+            continue;
+        }
+        return outcome;
+    }
+}
+async function openEntityPickDialog(args, entityName) {
+    const result = await args.layoutBuilder
+        .create()
+        .dialog((dialog) => {
+        dialog
+            .setTitle(CREATE_USER_QUERY_I18N.titles.entity)
+            .setSize('lg')
+            .setCloseButton(true)
+            .setContext(createInitialContext('entity', entityName))
+            .content((flex) => {
+            flex.setDirection('column').setGap('16px').stepWizard((wizard) => {
+                wizard
+                    .name(CREATE_USER_QUERY_WIZARD_NAME)
+                    .setLook('circular-icon')
+                    .setLinear(true)
+                    .setDirection('horizontal')
+                    .setShowActions(false)
+                    .step('entity', CREATE_USER_QUERY_I18N.steps.entity, (step) => {
+                    step.setIcon('fa-light fa-database').content((layout) => {
+                        fillEntityPickStep(layout);
+                    });
+                })
+                    .step('fields', CREATE_USER_QUERY_I18N.steps.fields, (step) => {
+                    step.setIcon('fa-light fa-diagram-project').content((layout) => {
+                        fillHintStep(layout, CREATE_USER_QUERY_I18N.steps.fields, CREATE_USER_QUERY_I18N.placeholders.fieldsNext);
+                    });
+                })
+                    .step('contract', CREATE_USER_QUERY_I18N.steps.contract, (step) => {
+                    step.setIcon('fa-light fa-file-contract').content((layout) => {
+                        fillContractPlaceholderStep(layout);
+                    });
+                });
+            });
+        })
+            .setActions((actions) => {
+            actions
+                .cancel('@general:actions.cancel.title')
+                .custom({
+                title: '@general:actions.next.title',
+                command: 'continue-to-fields',
+                icon: 'fa-regular fa-arrow-right',
+                color: 'primary',
+                hidden: '{{!api.getStatus().isFirst}}',
+                predicateApiWidgetName: CREATE_USER_QUERY_WIZARD_NAME,
+            })
+                .custom({
+                title: '@general:actions.next.title',
+                command: `widget:${CREATE_USER_QUERY_WIZARD_NAME}.next`,
+                icon: 'fa-regular fa-arrow-right',
+                color: 'primary',
+                hidden: '{{api.getStatus().isFirst || api.getStatus().isLast}}',
+                predicateApiWidgetName: CREATE_USER_QUERY_WIZARD_NAME,
+            })
+                .custom({
+                title: '@general:actions.submit.title',
+                command: `widget:${CREATE_USER_QUERY_WIZARD_NAME}.submit`,
+                icon: 'fa-regular fa-check',
+                color: 'success',
+                hidden: '{{!api.getStatus().isLast}}',
+                predicateApiWidgetName: CREATE_USER_QUERY_WIZARD_NAME,
+            });
+        })
+            .onAction(async (dialogRef) => {
+            if (dialogRef.action() === 'cancel') {
+                return null;
+            }
+            const context = dialogRef.context() ?? null;
+            const name = resolvePickedEntityFullName(context?.source?.entity?.entityName);
+            if (!name) {
+                throw new Error(CREATE_USER_QUERY_I18N.errors.entityRequired);
+            }
+            return name;
+        });
+    })
+        .show();
+    return resolveLayoutBuilderDialogResult(result);
+}
+async function openEntityFieldsDialog(args, entityName, groups, selectedGroups) {
+    const result = await args.layoutBuilder
+        .create()
+        .dialog((dialog) => {
+        dialog
+            .setTitle(CREATE_USER_QUERY_I18N.titles.entity)
+            .setSize('xl')
+            .setCloseButton(true)
+            .setContext(createInitialContext('entity', entityName, [], selectedGroups))
+            .content((flex) => {
+            flex.setDirection('column').setGap('16px').stepWizard((wizard) => {
+                wizard
+                    .name(CREATE_USER_QUERY_WIZARD_NAME)
+                    .setLook('circular-icon')
+                    .setLinear(true)
+                    .setDirection('horizontal')
+                    .setShowActions(false)
+                    .setGuards({
+                    next: (payload) => canLeaveEntityFieldsStep(payload, args, groups),
+                })
+                    .step('fields', CREATE_USER_QUERY_I18N.steps.fields, (step) => {
+                    step.setIcon('fa-light fa-diagram-project').content((layout) => {
+                        fillEntityFieldsStep(layout, entityName, groups);
+                    });
+                })
+                    .step('contract', CREATE_USER_QUERY_I18N.steps.contract, (step) => {
+                    step.setIcon('fa-light fa-file-contract').content((layout) => {
+                        fillContractPlaceholderStep(layout);
+                    });
+                });
+            });
+        })
+            .setActions((actions) => {
+            actions
+                .cancel('@general:actions.cancel.title')
+                .custom({
+                title: '@general:actions.previous.title',
+                command: 'back-to-entity',
+                icon: 'fa-regular fa-arrow-left',
+                color: 'primary',
+                position: 'prefix',
+                hidden: '{{!api.getStatus().isFirst}}',
+                predicateApiWidgetName: CREATE_USER_QUERY_WIZARD_NAME,
+            })
+                .custom({
+                title: '@general:actions.previous.title',
+                command: `widget:${CREATE_USER_QUERY_WIZARD_NAME}.previous`,
+                icon: 'fa-regular fa-arrow-left',
+                color: 'primary',
+                position: 'prefix',
+                hidden: '{{api.getStatus().isFirst}}',
+                predicateApiWidgetName: CREATE_USER_QUERY_WIZARD_NAME,
+            })
+                .custom({
+                title: '@general:actions.next.title',
+                command: `widget:${CREATE_USER_QUERY_WIZARD_NAME}.next`,
+                icon: 'fa-regular fa-arrow-right',
+                color: 'primary',
+                hidden: '{{api.getStatus().isLast}}',
+                predicateApiWidgetName: CREATE_USER_QUERY_WIZARD_NAME,
+            })
+                .custom({
+                title: '@general:actions.submit.title',
+                command: `widget:${CREATE_USER_QUERY_WIZARD_NAME}.submit`,
+                icon: 'fa-regular fa-check',
+                color: 'success',
+                hidden: '{{!api.getStatus().isLast}}',
+                predicateApiWidgetName: CREATE_USER_QUERY_WIZARD_NAME,
+            });
+        })
+            .onAction(async (dialogRef) => {
+            if (dialogRef.action() === 'cancel') {
+                return null;
+            }
+            if (dialogRef.action() === 'back-to-entity') {
+                return ENTITY_WIZARD_BACK;
+            }
+            const context = dialogRef.context() ?? null;
+            if (!context) {
+                return null;
+            }
+            const fields = withRequiredIdField(collectSelectedFieldGroupPaths(context.source?.entity?.fieldGroups, groups));
+            if (countFieldGroupItems(groups) > 0 && fields.filter((path) => path !== 'id').length === 0) {
+                throw new Error(CREATE_USER_QUERY_I18N.errors.fieldsRequired);
+            }
+            return {
+                ...context,
+                source: {
+                    ...context.source,
+                    kind: 'entity',
+                    entity: {
+                        entityName,
+                        fields,
+                        fieldGroups: context.source?.entity?.fieldGroups,
+                    },
+                },
+            };
+        });
+    })
+        .show();
+    return resolveLayoutBuilderDialogResult(result);
+}
+async function loadEntityFieldGraph(args, entityName) {
+    const parsed = parseEntityFullName(entityName);
+    if (!parsed) {
+        await showWizardWarning(args, CREATE_USER_QUERY_I18N.errors.entityLoadFailed);
+        return null;
+    }
+    const entity = await args.entityResolver.get(parsed.module, parsed.name);
+    if (!entity) {
+        await showWizardWarning(args, CREATE_USER_QUERY_I18N.errors.entityLoadFailed);
+        return null;
+    }
+    const relatedByName = await loadRelatedEntityClosure(args.entityResolver, entity.relatedEntities ?? []);
+    const groups = collectUserQueryEntityFieldGroups(entity, relatedByName);
+    return {
+        groups: await toFieldGroupViews(groups, args.translationService),
+        defaultGroups: defaultSelectedFieldGroups(groups),
+    };
+}
+async function loadRelatedEntityClosure(entityResolver, roots) {
+    const relatedByName = new Map();
+    let pending = [...new Set(roots.map((item) => item.entity?.trim() ?? '').filter(Boolean))];
+    for (let depth = 1; depth <= USER_QUERY_RELATED_DEPTH && pending.length > 0; depth += 1) {
+        const batch = pending.filter((name) => !relatedByName.has(name));
+        pending = [];
+        await Promise.all(batch.map(async (fullName) => {
+            const parsed = parseEntityFullName(fullName);
+            if (!parsed) {
+                return;
+            }
+            const definition = await entityResolver.get(parsed.module, parsed.name);
+            if (!definition) {
+                return;
+            }
+            relatedByName.set(fullName, definition);
+            for (const nested of definition.relatedEntities ?? []) {
+                const nestedName = nested.entity?.trim();
+                if (nestedName && !relatedByName.has(nestedName)) {
+                    pending.push(nestedName);
+                }
+            }
+        }));
+    }
+    return relatedByName;
+}
+//#endregion
+//#region ----- API sub-steps -----
+async function openApiSourceWizard(args) {
+    let previous = createApiWizardContext();
+    while (true) {
+        const tested = await openApiSourceDialog(args, previous);
+        if (!tested) {
+            return null;
+        }
+        const groups = inferJsonFieldGroups(tested.source?.api?.lastTest?.body);
+        const views = await toFieldGroupViews(groups, args.translationService);
+        const selected = isSameApiRequest(previous, tested) && previous.source?.api?.fieldGroups
+            ? previous.source.api.fieldGroups
+            : defaultHostFieldGroups(groups);
+        const outcome = await openApiFieldsDialog(args, tested, views, selected);
+        if (outcome === API_WIZARD_BACK) {
+            previous = tested;
+            continue;
+        }
+        return outcome;
+    }
+}
+async function openApiSourceDialog(args, previous) {
+    const result = await args.layoutBuilder
+        .create()
+        .dialog((dialog) => {
+        dialog
+            .setTitle(CREATE_USER_QUERY_I18N.titles.api)
+            .setSize('xl')
+            .setCloseButton(true)
+            .setContext(previous)
+            .content((flex) => {
+            flex.setDirection('column').setGap('16px').stepWizard((wizard) => {
+                wizard
+                    .name(CREATE_USER_QUERY_WIZARD_NAME)
+                    .setLook('circular-icon')
+                    .setLinear(true)
+                    .setDirection('horizontal')
+                    .setShowActions(false)
+                    .step('source', CREATE_USER_QUERY_I18N.steps.source, (step) => {
+                    step.setIcon('fa-light fa-cloud-arrow-up').content((layout) => {
+                        fillApiSourceStep(layout);
+                    });
+                })
+                    .step('fields', CREATE_USER_QUERY_I18N.steps.fields, (step) => {
+                    step.setIcon('fa-light fa-diagram-project').content((layout) => {
+                        fillHintStep(layout, CREATE_USER_QUERY_I18N.steps.fields, CREATE_USER_QUERY_I18N.placeholders.apiFieldsNext);
+                    });
+                })
+                    .step('contract', CREATE_USER_QUERY_I18N.steps.contract, (step) => {
+                    step.setIcon('fa-light fa-file-contract').content((layout) => {
+                        fillContractPlaceholderStep(layout);
+                    });
+                });
+            });
+        })
+            .setActions((actions) => {
+            actions
+                .cancel('@general:actions.cancel.title')
+                .custom({
+                title: '@general:actions.next.title',
+                command: 'continue-to-fields',
+                icon: 'fa-regular fa-arrow-right',
+                color: 'primary',
+                hidden: '{{!api.getStatus().isFirst}}',
+                predicateApiWidgetName: CREATE_USER_QUERY_WIZARD_NAME,
+            })
+                .custom({
+                title: '@general:actions.next.title',
+                command: `widget:${CREATE_USER_QUERY_WIZARD_NAME}.next`,
+                icon: 'fa-regular fa-arrow-right',
+                color: 'primary',
+                hidden: '{{api.getStatus().isFirst || api.getStatus().isLast}}',
+                predicateApiWidgetName: CREATE_USER_QUERY_WIZARD_NAME,
+            })
+                .custom({
+                title: '@general:actions.submit.title',
+                command: `widget:${CREATE_USER_QUERY_WIZARD_NAME}.submit`,
+                icon: 'fa-regular fa-check',
+                color: 'success',
+                hidden: '{{!api.getStatus().isLast}}',
+                predicateApiWidgetName: CREATE_USER_QUERY_WIZARD_NAME,
+            });
+        })
+            .onAction(async (dialogRef) => {
+            if (dialogRef.action() === 'cancel') {
+                return null;
+            }
+            const context = dialogRef.context() ?? null;
+            const request = normalizeRestApiOutput(context?.source?.api?.request);
+            if (!request.url) {
+                throw new Error(CREATE_USER_QUERY_I18N.errors.apiUrlRequired);
+            }
+            const lastTest = await runRestApiRequest(request);
+            if (!lastTest.ok) {
+                await showApiTestFailure(args, lastTest);
+                throw new Error(lastTest.status === 0 ? CREATE_USER_QUERY_I18N.errors.apiTestNetwork : CREATE_USER_QUERY_I18N.errors.apiTestFailed);
+            }
+            await showWizardWarning(args, CREATE_USER_QUERY_I18N.placeholders.apiTestOk, { status: String(lastTest.status) }, 'success');
+            return createApiWizardContext({
+                connectionId: context?.source?.api?.connectionId,
+                request,
+                lastTest,
+                fieldGroups: context?.source?.api?.fieldGroups,
+            });
+        });
+    })
+        .show();
+    return resolveLayoutBuilderDialogResult(result);
+}
+async function openApiFieldsDialog(args, tested, groups, selectedGroups) {
+    const result = await args.layoutBuilder
+        .create()
+        .dialog((dialog) => {
+        dialog
+            .setTitle(CREATE_USER_QUERY_I18N.titles.api)
+            .setSize('xl')
+            .setCloseButton(true)
+            .setContext(createApiWizardContext(tested.source?.api, selectedGroups))
+            .content((flex) => {
+            flex.setDirection('column').setGap('16px').stepWizard((wizard) => {
+                wizard
+                    .name(CREATE_USER_QUERY_WIZARD_NAME)
+                    .setLook('circular-icon')
+                    .setLinear(true)
+                    .setDirection('horizontal')
+                    .setShowActions(false)
+                    .setGuards({
+                    next: (payload) => canLeaveApiFieldsStep(payload, args, groups),
+                })
+                    .step('fields', CREATE_USER_QUERY_I18N.steps.fields, (step) => {
+                    step.setIcon('fa-light fa-diagram-project').content((layout) => {
+                        fillApiFieldsStep(layout, groups);
+                    });
+                })
+                    .step('contract', CREATE_USER_QUERY_I18N.steps.contract, (step) => {
+                    step.setIcon('fa-light fa-file-contract').content((layout) => {
+                        fillContractPlaceholderStep(layout);
+                    });
+                });
+            });
+        })
+            .setActions((actions) => {
+            actions
+                .cancel('@general:actions.cancel.title')
+                .custom({
+                title: '@general:actions.previous.title',
+                command: 'back-to-source',
+                icon: 'fa-regular fa-arrow-left',
+                color: 'primary',
+                position: 'prefix',
+                hidden: '{{!api.getStatus().isFirst}}',
+                predicateApiWidgetName: CREATE_USER_QUERY_WIZARD_NAME,
+            })
+                .custom({
+                title: '@general:actions.previous.title',
+                command: `widget:${CREATE_USER_QUERY_WIZARD_NAME}.previous`,
+                icon: 'fa-regular fa-arrow-left',
+                color: 'primary',
+                position: 'prefix',
+                hidden: '{{api.getStatus().isFirst}}',
+                predicateApiWidgetName: CREATE_USER_QUERY_WIZARD_NAME,
+            })
+                .custom({
+                title: '@general:actions.next.title',
+                command: `widget:${CREATE_USER_QUERY_WIZARD_NAME}.next`,
+                icon: 'fa-regular fa-arrow-right',
+                color: 'primary',
+                hidden: '{{api.getStatus().isLast}}',
+                predicateApiWidgetName: CREATE_USER_QUERY_WIZARD_NAME,
+            })
+                .custom({
+                title: '@general:actions.submit.title',
+                command: `widget:${CREATE_USER_QUERY_WIZARD_NAME}.submit`,
+                icon: 'fa-regular fa-check',
+                color: 'success',
+                hidden: '{{!api.getStatus().isLast}}',
+                predicateApiWidgetName: CREATE_USER_QUERY_WIZARD_NAME,
+            });
+        })
+            .onAction(async (dialogRef) => {
+            if (dialogRef.action() === 'cancel') {
+                return null;
+            }
+            if (dialogRef.action() === 'back-to-source') {
+                return API_WIZARD_BACK;
+            }
+            const context = dialogRef.context() ?? null;
+            if (!context) {
+                return null;
+            }
+            const fields = collectSelectedFieldGroupPaths(context.source?.api?.fieldGroups, groups);
+            if (countFieldGroupItems(groups) > 0 && fields.length === 0) {
+                throw new Error(CREATE_USER_QUERY_I18N.errors.fieldsRequired);
+            }
+            return createApiWizardContext({
+                ...tested.source?.api,
+                fields,
+                fieldGroups: context.source?.api?.fieldGroups,
+            });
+        });
+    })
+        .show();
+    return resolveLayoutBuilderDialogResult(result);
+}
+function fillApiFieldsStep(layout, groups) {
+    layout.flex((flex) => {
+        flex.setDirection('column').setGap('16px').setAlignItems('stretch');
+        flex.fieldset((fieldset) => {
+            fieldset
+                .setTitle(CREATE_USER_QUERY_I18N.fields.sample)
+                .setDescription(CREATE_USER_QUERY_I18N.placeholders.selectedApiHint)
+                .setIcon('fa-light fa-code')
+                .setCols(1)
+                .formField(CREATE_USER_QUERY_I18N.fields.status, (field) => {
+                field.path('source.api.lastTest.status').textBox().readonly(true);
+            })
+                .formField(CREATE_USER_QUERY_I18N.fields.sample, (field) => {
+                field.path('source.api.lastTest.body').customWidget('json-viewer', {}).layout(1);
+            });
+        });
+        for (const group of groups) {
+            renderFieldGroup(flex, group, 'source.api.fieldGroups');
+        }
+    });
+}
+async function canLeaveApiFieldsStep(payload, args, groups) {
+    if (payload.step?.id !== 'fields') {
+        return true;
+    }
+    if (countFieldGroupItems(groups) === 0) {
+        return true;
+    }
+    const context = (payload.context ?? {});
+    const selected = collectSelectedFieldGroupPaths(context.source?.api?.fieldGroups, groups);
+    if (selected.length > 0) {
+        return true;
+    }
+    await showWizardWarning(args, CREATE_USER_QUERY_I18N.errors.fieldsRequired);
+    return false;
+}
+function createApiWizardContext(api, fieldGroups = {}) {
+    const base = createInitialContext('api');
+    return {
+        ...base,
+        source: {
+            ...base.source,
+            api: {
+                request: api?.request ?? createEmptyRestApiOutput(),
+                connectionId: api?.connectionId,
+                lastTest: api?.lastTest
+                    ? { ...api.lastTest, status: String(api.lastTest.status) }
+                    : undefined,
+                fields: api?.fields ?? [],
+                fieldGroups: Object.keys(fieldGroups).length ? fieldGroups : (api?.fieldGroups ?? {}),
+            },
+        },
+    };
+}
+function isSameApiRequest(left, right) {
+    return JSON.stringify(left.source?.api?.request) === JSON.stringify(right.source?.api?.request);
+}
+async function showApiTestFailure(args, lastTest) {
+    if (Number(lastTest.status) === 0) {
+        await showWizardWarning(args, CREATE_USER_QUERY_I18N.errors.apiTestNetwork);
+        return;
+    }
+    await showWizardWarning(args, CREATE_USER_QUERY_I18N.errors.apiTestFailed, { status: String(lastTest.status) });
+}
+async function runRestApiRequest(value) {
+    const request = normalizeRestApiOutput(value);
+    const url = buildApiRequestUrl(request);
+    if (!url) {
+        return { ok: false, status: 0, body: null };
+    }
+    const headers = {};
+    if (request.headers['ContentType'].trim()) {
+        headers['Content-Type'] = request.headers['ContentType'].trim();
+    }
+    if (request.headers['Authorization'].trim()) {
+        headers['Authorization'] = request.headers['Authorization'].trim();
+    }
+    for (const [key, headerValue] of Object.entries(request.headers)) {
+        if (key === 'Authorization' || key === 'ContentType' || key === 'tempId') {
+            continue;
+        }
+        if (typeof headerValue === 'string' && headerValue.trim()) {
+            headers[key] = headerValue.trim();
+        }
+    }
+    try {
+        const response = await fetch(url, {
+            method: request.method,
+            headers,
+            body: request.method === 'GET' || !request.body.trim() ? undefined : request.body,
+            credentials: 'omit',
+            signal: AbortSignal.timeout(15000),
+        });
+        const text = (await response.text()).trim();
+        let body = text || null;
+        if (text) {
+            try {
+                body = JSON.parse(text);
+            }
+            catch {
+                body = text;
+            }
+        }
+        return {
+            ok: response.status >= 200 && response.status < 300,
+            status: response.status,
+            body,
+        };
+    }
+    catch {
+        return { ok: false, status: 0, body: null };
+    }
+}
+function buildApiRequestUrl(request) {
+    const base = request.url.trim();
+    if (!base) {
+        return '';
+    }
+    const params = new URLSearchParams();
+    for (const query of request.queries ?? []) {
+        for (const [key, value] of Object.entries(query)) {
+            if (key === 'tempId' || !String(key).trim() || value == null || !String(value).trim()) {
+                continue;
+            }
+            params.append(key, String(value).trim());
+        }
+    }
+    const search = params.toString();
+    if (!search) {
+        return base;
+    }
+    return base.includes('?') ? `${base}&${search}` : `${base}?${search}`;
+}
+function inferJsonFieldGroups(sample) {
+    const root = firstPlainObject(sample);
+    if (!root) {
+        return [];
+    }
+    const envelope = splitJsonEnvelope(root);
+    if (!envelope) {
+        return jsonGroupsFromObject(root, '', 0, true);
+    }
+    const groups = jsonGroupsFromObject(envelope.record, envelope.path, 0, true);
+    if (envelope.meta.length > 0) {
+        groups.push({
+            id: 'response',
+            kind: 'lookup',
+            title: CREATE_USER_QUERY_I18N.fields.response,
+            fallback: 'response',
+            items: envelope.meta,
+        });
+    }
+    return groups;
+}
+function splitJsonEnvelope(root) {
+    const payloadKeys = ['data', 'result', 'results', 'items', 'records', 'value', 'payload', 'content'];
+    const flagKeys = new Set(['ok', 'success', 'status', 'kind', 'error', 'code', 'message']);
+    const metaObjectKeys = new Set(['info', 'meta', 'pagination', 'support', 'links', 'page']);
+    const keys = Object.keys(root);
+    const namedPayload = payloadKeys.find((key) => root[key] != null);
+    const hasFlag = keys.some((key) => flagKeys.has(key) && isJsonScalar(root[key]));
+    let payloadKey = namedPayload;
+    if (payloadKey) {
+        const rest = keys.filter((key) => key !== payloadKey);
+        const restAreMeta = rest.every((key) => isJsonScalar(root[key]) || flagKeys.has(key) || metaObjectKeys.has(key));
+        if (!hasFlag && !restAreMeta) {
+            payloadKey = undefined;
+        }
+    }
+    else {
+        const arrayKeys = keys.filter((key) => {
+            const value = root[key];
+            return Array.isArray(value) && value.some((item) => isPlainObject(item));
+        });
+        const otherKeys = keys.filter((key) => !arrayKeys.includes(key));
+        if (arrayKeys.length === 1 &&
+            otherKeys.length > 0 &&
+            otherKeys.every((key) => isJsonScalar(root[key]))) {
+            payloadKey = arrayKeys[0];
+        }
+    }
+    if (!payloadKey) {
+        return null;
+    }
+    const payload = root[payloadKey];
+    const meta = [];
+    for (const [key, value] of Object.entries(root)) {
+        if (key === payloadKey || !isJsonScalar(value)) {
+            continue;
+        }
+        meta.push({ path: key, fallback: key });
+    }
+    if (Array.isArray(payload)) {
+        const record = firstPlainObject(payload);
+        if (!record) {
+            return null;
+        }
+        return { record, path: payloadKey, meta };
+    }
+    if (isPlainObject(payload)) {
+        const items = payload['items'];
+        if (Array.isArray(items)) {
+            const record = firstPlainObject(items);
+            if (record) {
+                for (const [key, value] of Object.entries(payload)) {
+                    if (key === 'items' || !isJsonScalar(value)) {
+                        continue;
+                    }
+                    meta.push({ path: `${payloadKey}.${key}`, fallback: key });
+                }
+                return { record, path: `${payloadKey}.items`, meta };
+            }
+        }
+        return { record: payload, path: payloadKey, meta };
+    }
+    meta.push({ path: payloadKey, fallback: payloadKey });
+    return { record: { value: payload }, path: payloadKey, meta };
+}
+function jsonGroupsFromObject(value, prefix, depth, asHost = false) {
+    const scalars = [];
+    const nested = [];
+    for (const [key, raw] of Object.entries(value)) {
+        const path = prefix ? `${prefix}.${key}` : key;
+        const unwrapped = Array.isArray(raw) ? firstPlainObject(raw) : raw;
+        if (isPlainObject(unwrapped) && depth < 2) {
+            nested.push({ key, path, value: unwrapped });
+            continue;
+        }
+        scalars.push({ path, fallback: key });
+    }
+    const groups = [];
+    if (scalars.length > 0) {
+        const leaf = prefix.includes('.') ? (prefix.split('.').pop() ?? prefix) : prefix;
+        const isHost = (asHost && depth === 0) || !prefix;
+        groups.push({
+            id: isHost ? 'host' : `rel_${prefix.replace(/[^a-zA-Z0-9]+/g, '_')}_fields`,
+            kind: isHost ? 'host' : 'relation',
+            title: leaf,
+            fallback: leaf || 'fields',
+            items: scalars,
+        });
+    }
+    if (depth >= 2) {
+        return groups;
+    }
+    for (const item of nested) {
+        const children = jsonGroupsFromObject(item.value, item.path, depth + 1, false);
+        groups.push({
+            id: `rel_${item.path.replace(/[^a-zA-Z0-9]+/g, '_')}`,
+            kind: 'relation',
+            title: item.key,
+            fallback: item.key,
+            items: [],
+            children: children.length > 0 ? children : undefined,
+        });
+    }
+    return groups;
+}
+function defaultHostFieldGroups(groups) {
+    const selected = {};
+    const walk = (group) => {
+        selected[group.id] = group.kind === 'host' ? group.items.map((item) => item.path) : [];
+        for (const child of group.children ?? []) {
+            walk(child);
+        }
+    };
+    for (const group of groups) {
+        walk(group);
+    }
+    return selected;
+}
+function firstPlainObject(value) {
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            const found = firstPlainObject(item);
+            if (found) {
+                return found;
+            }
+        }
+        return null;
+    }
+    return isPlainObject(value) ? value : null;
+}
+function isPlainObject(value) {
+    return value != null && typeof value === 'object' && !Array.isArray(value);
+}
+function isJsonScalar(value) {
+    if (value == null) {
+        return true;
+    }
+    const type = typeof value;
+    return type === 'string' || type === 'number' || type === 'boolean';
+}
+//#endregion
+//#region ----- Advanced placeholder -----
+async function openAdvancedPlaceholder(args) {
+    await args.layoutBuilder
+        .create()
+        .dialog((dialog) => {
+        dialog
+            .setTitle(CREATE_USER_QUERY_I18N.titles.advanced)
+            .setMessage(CREATE_USER_QUERY_I18N.placeholders.advanced)
+            .setSize('md')
+            .setCloseButton(true)
+            .setActions((actions) => {
+            actions.cancel('@general:actions.close.title');
+        })
+            .onAction(async () => null);
+    })
+        .show();
+    return null;
+}
+//#endregion
+//#region ----- Simple source wizard -----
+function configureSimpleSourceWizard(dialog, args) {
+    dialog
+        .setTitle(dialogTitleKey(args.sourceKind))
+        .setSize(args.sourceKind === 'api' ? 'xl' : 'lg')
+        .setCloseButton(true)
+        .setContext(createInitialContext(args.sourceKind))
+        .content((flex) => {
+        flex.setDirection('column').setGap('16px').stepWizard((wizard) => {
+            wizard
+                .name(CREATE_USER_QUERY_WIZARD_NAME)
+                .setLook('circular-icon')
+                .setLinear(true)
+                .setDirection('horizontal')
+                .setShowActions(false)
+                .setGuards({
+                next: (payload) => canLeaveSourceStep(payload, args),
+            })
+                .step('source', CREATE_USER_QUERY_I18N.steps.source, (step) => {
+                step.setIcon(sourceStepIcon(args.sourceKind)).content((layout) => {
+                    fillSourceStep(layout, args);
+                });
+            })
+                .step('contract', CREATE_USER_QUERY_I18N.steps.contract, (step) => {
+                step.setIcon('fa-light fa-file-contract').content((layout) => {
+                    fillContractPlaceholderStep(layout);
+                });
+            });
+        });
+    })
+        .setActions((actions) => {
+        actions
+            .cancel('@general:actions.cancel.title')
+            .custom({
+            title: '@general:actions.previous.title',
+            command: `widget:${CREATE_USER_QUERY_WIZARD_NAME}.previous`,
+            icon: 'fa-regular fa-arrow-left',
+            color: 'primary',
+            position: 'prefix',
+            disabled: '{{api.getStatus().isFirst}}',
+            predicateApiWidgetName: CREATE_USER_QUERY_WIZARD_NAME,
+        })
+            .custom({
+            title: '@general:actions.next.title',
+            command: `widget:${CREATE_USER_QUERY_WIZARD_NAME}.next`,
+            icon: 'fa-regular fa-arrow-right',
+            color: 'primary',
+            hidden: '{{api.getStatus().isLast}}',
+            predicateApiWidgetName: CREATE_USER_QUERY_WIZARD_NAME,
+        })
+            .custom({
+            title: '@general:actions.submit.title',
+            command: `widget:${CREATE_USER_QUERY_WIZARD_NAME}.submit`,
+            icon: 'fa-regular fa-check',
+            color: 'success',
+            hidden: '{{!api.getStatus().isLast}}',
+            predicateApiWidgetName: CREATE_USER_QUERY_WIZARD_NAME,
+        });
+    })
+        .onAction(async (dialogRef) => {
+        if (dialogRef.action() === 'cancel') {
+            return null;
+        }
+        return dialogRef.context() ?? null;
+    });
+}
+//#endregion
+//#region ----- Step bodies -----
+function fillSourceStep(layout, args) {
+    switch (args.sourceKind) {
+        case 'static':
+            fillStaticSourceStep(layout);
+            return;
+        case 'api':
+            fillApiSourceStep(layout);
+            return;
+        default:
+            return;
+    }
+}
+function fillEntityPickStep(layout, readonly = false) {
+    layout.fieldset((fieldset) => {
+        fieldset.setTitle(CREATE_USER_QUERY_I18N.steps.entity).setIcon('fa-light fa-database').setCols(1);
+        if (!readonly) {
+            fieldset.setDescription(CREATE_USER_QUERY_I18N.placeholders.fieldsNext);
+        }
+        fieldset.formField(CREATE_USER_QUERY_I18N.fields.entity, (field) => {
+            field.path('source.entity.entityName').lookupBox({
+                entity: CREATE_USER_QUERY_ENTITY_CATALOG,
+                valueField: 'id',
+                textField: 'id',
+                columns: ['name', 'module_id'],
+                look: 'select',
+                searchable: true,
+                allowClear: !readonly,
+                validations: readonly ? undefined : [{ rule: 'required' }],
+            });
+            if (readonly) {
+                field.readonly(true);
+            }
+        });
+    });
+}
+function fillEntityFieldsStep(layout, entityName, groups) {
+    layout.flex((flex) => {
+        flex.setDirection('column').setGap('16px').setAlignItems('stretch');
+        flex.fieldset((fieldset) => {
+            fieldset
+                .setTitle(entityName)
+                .setDescription(CREATE_USER_QUERY_I18N.placeholders.selectedEntityHint)
+                .setIcon('fa-light fa-database')
+                .setLook('group');
+        });
+        for (const group of groups) {
+            renderFieldGroup(flex, group);
+        }
+    });
+}
+function renderFieldGroup(layout, group, fieldGroupsPath = 'source.entity.fieldGroups') {
+    if (group.kind === 'relation' && (group.children?.length ?? 0) > 0) {
+        layout.panel((panel) => {
+            panel.setCaption(group.title).setIcon('fa-light fa-link').setLook('outline');
+            if (group.items.length) {
+                panel.fieldset((fieldset) => {
+                    appendFieldGroupList(fieldset, group, CREATE_USER_QUERY_I18N.fields.hostFields, fieldGroupsPath);
+                });
+            }
+            for (const child of group.children ?? []) {
+                renderFieldGroupOnPanel(panel, child, fieldGroupsPath);
+            }
+        });
+        return;
+    }
+    layout.fieldset((fieldset) => {
+        appendFieldGroupList(fieldset, group, group.title, fieldGroupsPath);
+    });
+}
+function renderFieldGroupOnPanel(panel, group, fieldGroupsPath = 'source.entity.fieldGroups') {
+    if ((group.children?.length ?? 0) > 0) {
+        panel.panel((inner) => {
+            inner.setCaption(group.title).setIcon('fa-light fa-link').setLook('outline');
+            if (group.items.length) {
+                inner.fieldset((fieldset) => {
+                    appendFieldGroupList(fieldset, group, CREATE_USER_QUERY_I18N.fields.hostFields, fieldGroupsPath);
+                });
+            }
+            for (const child of group.children ?? []) {
+                renderFieldGroupOnPanel(inner, child, fieldGroupsPath);
+            }
+        });
+        return;
+    }
+    panel.fieldset((fieldset) => {
+        appendFieldGroupList(fieldset, group, group.title, fieldGroupsPath);
+    });
+}
+function appendFieldGroupList(fieldset, group, title, fieldGroupsPath = 'source.entity.fieldGroups') {
+    fieldset.setTitle(title).setIcon(fieldGroupIcon(group.kind)).setCols(1);
+    if (group.kind === 'host') {
+        fieldset.setDescription(fieldGroupsPath.startsWith('source.api') ? CREATE_USER_QUERY_I18N.placeholders.apiFields : CREATE_USER_QUERY_I18N.placeholders.entityFields);
+    }
+    if (!group.items.length) {
+        return;
+    }
+    fieldset.formField(' ', (field) => {
+        field.path(`${fieldGroupsPath}.${group.id}`).selectionList({
+            dataSource: group.items,
+            valueField: 'path',
+            textField: 'text',
+            multiple: true,
+            searchable: group.items.length > 8,
+            direction: { id: 'vertical' },
+        });
+    });
+}
+function fieldGroupIcon(kind) {
+    if (kind === 'relation') {
+        return 'fa-light fa-link';
+    }
+    if (kind === 'lookup') {
+        return 'fa-light fa-diagram-nested';
+    }
+    return 'fa-light fa-list';
+}
+function fillHintStep(layout, titleKey, descriptionKey) {
+    layout.fieldset((fieldset) => {
+        fieldset.setTitle(titleKey).setDescription(descriptionKey).setIcon('fa-light fa-diagram-project').setLook('group');
+    });
+}
+function fillStaticSourceStep(layout) {
+    layout.fieldset((fieldset) => {
+        fieldset
+            .setTitle(CREATE_USER_QUERY_I18N.steps.source)
+            .setDescription(CREATE_USER_QUERY_I18N.placeholders.itemsHint)
+            .setIcon('fa-light fa-list')
+            .setCols(1)
+            .formField(' ', (field) => {
+            field
+                .path('source.static.items')
+                .setShowLabel(false)
+                .customWidget(AXPWidgetsList.Layouts.RepeaterLayout, {
+                hasControls: true,
+                allowReorder: true,
+                children: staticItemRepeaterChildren(),
+            })
+                .layout(1);
+        });
+    });
+}
+function staticItemRepeaterChildren() {
+    return [
+        {
+            type: AXPWidgetsList.Layouts.FlexLayout,
+            mode: 'edit',
+            options: {
+                flexDirection: 'row',
+                gap: '12px',
+                alignItems: 'stretch',
+            },
+            children: [
+                staticItemRepeaterField(CREATE_USER_QUERY_I18N.fields.value, 'value'),
+                staticItemRepeaterField(CREATE_USER_QUERY_I18N.fields.title, 'title'),
+            ],
+        },
+    ];
+}
+function staticItemRepeaterField(label, path) {
+    return {
+        type: AXPWidgetsList.Layouts.FlexItemLayout,
+        options: { grow: 1 },
+        children: [
+            {
+                type: AXPWidgetsList.Layouts.FormField,
+                options: { label, showLabel: true },
+                children: [
+                    {
+                        type: AXPWidgetsList.Editors.TextBox,
+                        path,
+                        name: path,
+                        mode: 'edit',
+                    },
+                ],
+            },
+        ],
+    };
+}
+function fillApiSourceStep(layout) {
+    layout.fieldset((fieldset) => {
+        fieldset
+            .setTitle(CREATE_USER_QUERY_I18N.steps.source)
+            .setDescription(CREATE_USER_QUERY_I18N.placeholders.apiFieldsNext)
+            .setIcon('fa-light fa-cloud-arrow-up')
+            .setCols(1)
+            .formField(CREATE_USER_QUERY_I18N.fields.connection, (field) => {
+            field
+                .path('source.api.connectionId')
+                .lookupBox({
+                entity: 'IntegrationManagement.IntegrationConnection',
+                searchable: true,
+                allowClear: true,
+            })
+                .layout(1);
+        })
+            .formField(CREATE_USER_QUERY_I18N.fields.request, (field) => {
+            field.path('source.api.request').customWidget(REST_API_GENERATOR_WIDGET_NAME, {}).layout(1);
+        });
+    });
+}
+function fillContractPlaceholderStep(layout) {
+    layout.fieldset((fieldset) => {
+        fieldset
+            .setTitle(CREATE_USER_QUERY_I18N.steps.contract)
+            .setDescription(CREATE_USER_QUERY_I18N.placeholders.contract)
+            .setIcon('fa-light fa-file-contract')
+            .setLook('group');
+    });
+}
+//#endregion
+//#region ----- Guards & helpers -----
+async function canLeaveSourceStep(payload, args) {
+    if (payload.step?.id !== 'source') {
+        return true;
+    }
+    const context = (payload.context ?? {});
+    const errorKey = sourceStepErrorKey(args.sourceKind, context);
+    if (!errorKey) {
+        return true;
+    }
+    await showWizardWarning(args, errorKey);
+    return false;
+}
+async function canLeaveEntityFieldsStep(payload, args, groups) {
+    if (payload.step?.id !== 'fields') {
+        return true;
+    }
+    if (countFieldGroupItems(groups) === 0) {
+        return true;
+    }
+    const context = (payload.context ?? {});
+    const selected = collectSelectedFieldGroupPaths(context.source?.entity?.fieldGroups, groups).filter((path) => path !== 'id');
+    if (selected.length > 0) {
+        return true;
+    }
+    await showWizardWarning(args, CREATE_USER_QUERY_I18N.errors.fieldsRequired);
+    return false;
+}
+function sourceStepErrorKey(sourceKind, context) {
+    if (sourceKind === 'static') {
+        const hasValue = (context.source?.static?.items ?? []).some((row) => String(row?.value ?? '').trim());
+        return hasValue ? null : CREATE_USER_QUERY_I18N.errors.staticRequired;
+    }
+    if (sourceKind === 'api') {
+        const url = context.source?.api?.request?.url?.trim() ?? '';
+        return url ? null : CREATE_USER_QUERY_I18N.errors.apiUrlRequired;
+    }
+    return null;
+}
+function createInitialContext(sourceKind, entityName = '', fields = [], fieldGroups = {}) {
+    const items = [{ value: '', title: '' }];
+    return {
+        sourceKind,
+        source: {
+            kind: sourceKind,
+            entity: { entityName, fields, fieldGroups },
+            static: { items },
+            api: { request: createEmptyRestApiOutput() },
+        },
+    };
+}
+function countFieldGroupItems(groups) {
+    let count = 0;
+    const walk = (group) => {
+        count += group.items.length;
+        for (const child of group.children ?? []) {
+            walk(child);
+        }
+    };
+    for (const group of groups) {
+        walk(group);
+    }
+    return count;
+}
+async function toFieldGroupViews(groups, translationService) {
+    const hostTitle = resolveLabel(translationService, CREATE_USER_QUERY_I18N.fields.hostFields, 'Fields');
+    const mapGroup = async (group) => {
+        const resolvedName = resolveLabel(translationService, group.title, group.fallback);
+        let title = resolvedName;
+        if (group.kind === 'host') {
+            title = hostTitle;
+        }
+        else if (group.kind === 'relation') {
+            title = await formatRelatedGroupTitle(translationService, resolvedName);
+        }
+        const children = group.children?.length
+            ? await Promise.all(group.children.map((child) => mapGroup(child)))
+            : undefined;
+        return {
+            id: group.id,
+            kind: group.kind,
+            title,
+            items: group.items.map((item) => ({
+                path: item.path,
+                text: resolveLabel(translationService, item.title, item.fallback),
+            })),
+            children,
+        };
+    };
+    return Promise.all(groups.map((group) => mapGroup(group)));
+}
+async function formatRelatedGroupTitle(translationService, name) {
+    const translated = await translationService.translateAsync(CREATE_USER_QUERY_I18N.placeholders.relatedTo, { params: { name } });
+    return typeof translated === 'string' && translated.trim() ? translated.trim() : name;
+}
+function resolveLabel(translationService, value, fallback) {
+    if (value == null || value === '') {
+        return fallback;
+    }
+    const resolved = translationService.resolve(value);
+    const text = typeof resolved === 'string' ? resolved.trim() : '';
+    return text || fallback;
+}
+async function showWizardWarning(args, errorKey, params, color = 'warning') {
+    const message = await args.translationService.translateAsync(errorKey, params ? { params } : undefined);
+    args.toastService.show({
+        color,
+        content: message,
+        closeButton: true,
+        timeOut: 4000,
+        timeOutProgress: true,
+    });
+}
+function dialogTitleKey(sourceKind) {
+    if (sourceKind === 'static') {
+        return CREATE_USER_QUERY_I18N.titles.static;
+    }
+    if (sourceKind === 'api') {
+        return CREATE_USER_QUERY_I18N.titles.api;
+    }
+    return CREATE_USER_QUERY_I18N.titles.entity;
+}
+function sourceStepIcon(sourceKind) {
+    if (sourceKind === 'static') {
+        return 'fa-light fa-list';
+    }
+    if (sourceKind === 'api') {
+        return 'fa-light fa-cloud-arrow-up';
+    }
+    return 'fa-light fa-database';
+}
+//#endregion
+
+//#region ----- Imports -----
+//#endregion
+//#region ----- Command -----
+/**
+ * Opens the user-query create wizard. Step 1 configures the source; nothing is persisted.
+ */
+class AXMCreateUserQueryCommand {
+    constructor() {
+        //#region ----- Services & Dependencies -----
+        this.layoutBuilder = inject(AXPLayoutBuilderService);
+        this.entityResolver = inject(AXPEntityResolver);
+        this.toastService = inject(AXToastService);
+        this.translationService = inject(AXTranslationService);
+    }
+    //#endregion
+    //#region ----- Execution -----
+    async execute(input = {}) {
+        const sourceKind = resolveSourceKind(input);
+        await openCreateUserQueryWizard({
+            layoutBuilder: this.layoutBuilder,
+            toastService: this.toastService,
+            translationService: this.translationService,
+            entityResolver: this.entityResolver,
+            sourceKind,
+        });
+        return {
+            success: true,
+            kind: 'object',
+            data: { sourceKind },
+            metadata: { refresh: false },
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMCreateUserQueryCommand, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMCreateUserQueryCommand, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMCreateUserQueryCommand, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//#endregion
+//#region ----- Helpers -----
+function resolveSourceKind(input) {
+    const resolved = resolveEntityActionCommandInput(input);
+    const data = entityActionDataRecord(resolved.data) ?? {};
+    const options = (resolved.options ?? {});
+    const process = (options['process'] ?? {});
+    const processData = (process['data'] ?? {});
+    const raw = data['sourceKind'] ?? processData['sourceKind'];
+    if (raw === 'static' || raw === 'api' || raw === 'advanced' || raw === 'entity') {
+        return raw;
+    }
+    return 'entity';
+}
+
+export { AXMCreateUserQueryCommand };
+//# sourceMappingURL=acorex-platform-module-platform-management-client-create-user-query.command-2Qu7aoCp.mjs.map