@acorex-platform/module-platform-management-client 0.0.38 → 0.0.46

package/fesm2022/acorex-platform-module-platform-management-client-create-user-query-contract.util-D_af2BUi.mjs

@@ -0,0 +1,586 @@
+import { AXP_QUERY_DEFAULT_COLLECTION_PAGING } from '@acorex-platform/framework-shared/runtime';
+import { parsePropertyExposeEntries } from '@acorex-platform/framework-shared/entity';
+
+//#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 isNumericUserQueryField(item) {
+    return String(item.dataType ?? '').toLowerCase() === 'number';
+}
+function numericUserQueryFields(fields) {
+    return fields.filter(isNumericUserQueryField);
+}
+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,
+            filterWidget: resolveFilterWidget(property),
+            dataType: String(property.schema?.dataType ?? ''),
+        });
+    }
+    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,
+            filterWidget: 'lookup-filter',
+        },
+    ];
+    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 resolveFilterWidget(property) {
+    const widgetType = typeof property.schema?.interface?.type === 'string' ? property.schema.interface.type : '';
+    if (LOOKUP_WIDGET_TYPES.has(widgetType)) {
+        return 'lookup-filter';
+    }
+    const dataType = String(property.schema?.dataType ?? '').toLowerCase();
+    const widget = widgetType.toLowerCase();
+    if (dataType === 'number' || widget.includes('number')) {
+        return 'number-filter';
+    }
+    if (dataType === 'boolean' || widget.includes('check') || widget.includes('toggle')) {
+        return 'boolean-filter';
+    }
+    if (dataType === 'date' || widget.includes('date')) {
+        return 'datetime-filter';
+    }
+    return 'string-filter';
+}
+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 -----
+//#endregion
+//#region ----- Constants -----
+const TEXT_FIELD_PREFERENCE = ['title', 'name', 'displayName', 'code'];
+const FIELD_INTERFACE = { name: 'text-editor' };
+const VALUE_REDUCERS = ['count', 'sum', 'min', 'max', 'avg'];
+const DEFAULT_USER_QUERY_MEASURE = {
+    reducer: 'count',
+    alias: 'value',
+};
+const DEFAULT_USER_QUERY_PAGING = {
+    enabled: true,
+    definition: { ...AXP_QUERY_DEFAULT_COLLECTION_PAGING },
+};
+//#endregion
+//#region ----- Public API -----
+function suggestedUserQueryName(entityFullName) {
+    const trimmed = entityFullName.trim();
+    return trimmed ? `UserQuery:${trimmed}` : '';
+}
+function flattenEntityFieldItems(groups) {
+    const items = [];
+    const walk = (group) => {
+        items.push(...group.items);
+        for (const child of group.children ?? []) {
+            walk(child);
+        }
+    };
+    for (const group of groups) {
+        walk(group);
+    }
+    return items;
+}
+function selectedFieldPathsFromGroups(fieldGroups) {
+    if (!fieldGroups) {
+        return withRequiredIdField([]);
+    }
+    const paths = [];
+    for (const value of Object.values(fieldGroups)) {
+        paths.push(...normalizeSelectedFieldPaths(value));
+    }
+    return withRequiredIdField(paths);
+}
+function resolveAvailableContractFields(allFields, selectedPaths) {
+    const ordered = withRequiredIdField(selectedPaths);
+    const byPath = new Map(allFields.map((field) => [field.path, field]));
+    return ordered.map((path) => byPath.get(path) ?? { path, text: path });
+}
+function defaultContractBinding(fields) {
+    const paths = fields.map((field) => field.path);
+    const valueField = paths.includes('id') ? 'id' : (paths[0] ?? 'id');
+    const preferred = TEXT_FIELD_PREFERENCE.find((name) => paths.includes(name) && name !== valueField);
+    const textField = preferred ?? paths.find((path) => path !== valueField) ?? valueField;
+    return { valueField, textField };
+}
+function toFilterDefinitions(fields) {
+    return fields.map((field) => ({
+        name: field.path,
+        title: field.text || field.path,
+        source: 'field',
+        field: field.path,
+        interface: FIELD_INTERFACE,
+    }));
+}
+function toSortDefinitions(fields) {
+    return fields.map((field) => ({
+        name: field.path,
+        title: field.text || field.path,
+        source: 'field',
+        field: field.path,
+        directions: ['asc', 'desc'],
+    }));
+}
+function toColumnDefinitions(fields) {
+    return fields.map((field) => ({
+        name: field.path,
+        title: field.text || field.path,
+        interface: FIELD_INTERFACE,
+    }));
+}
+function toFilterSection(fields) {
+    if (fields.length === 0) {
+        return { enabled: false };
+    }
+    return { enabled: true, definition: toFilterDefinitions(fields) };
+}
+function toSortSection(fields) {
+    if (fields.length === 0) {
+        return { enabled: false };
+    }
+    return { enabled: true, definition: toSortDefinitions(fields) };
+}
+function pathsFromFilterSection(section) {
+    if (!section?.enabled) {
+        return [];
+    }
+    return section.definition.map((item) => item.field ?? item.name).filter((path) => path.trim().length > 0);
+}
+function pathsFromSortSection(section) {
+    if (!section?.enabled) {
+        return [];
+    }
+    return section.definition.map((item) => item.field ?? item.name).filter((path) => path.trim().length > 0);
+}
+function createDefaultContractCapabilities(available) {
+    return {
+        filter: { enabled: false },
+        sort: toSortSection(available),
+        paging: { enabled: true, definition: { ...AXP_QUERY_DEFAULT_COLLECTION_PAGING } },
+        binding: defaultContractBinding(available),
+    };
+}
+function normalizeUserQueryKind(value) {
+    return value === 'value' || value === 'object' || value === 'collection' ? value : 'collection';
+}
+function normalizeUserQueryValueType(value) {
+    return value === 'string' ||
+        value === 'number' ||
+        value === 'boolean' ||
+        value === 'date' ||
+        value === 'datetime' ||
+        value === 'json'
+        ? value
+        : 'string';
+}
+function isCollectionQueryKind(value) {
+    return normalizeUserQueryKind(value) === 'collection';
+}
+function isValueQueryKind(value) {
+    return normalizeUserQueryKind(value) === 'value';
+}
+function normalizeUserQueryMeasure(value, available) {
+    const record = value != null && typeof value === 'object' ? value : {};
+    const reducer = VALUE_REDUCERS.includes(record['reducer'])
+        ? record['reducer']
+        : 'count';
+    if (reducer === 'count') {
+        return { reducer: 'count', alias: 'value' };
+    }
+    const numeric = available.filter(isNumericUserQueryField);
+    const field = typeof record['field'] === 'string' ? record['field'].trim() : '';
+    const availableSet = new Set(numeric.map((item) => item.path));
+    const resolved = availableSet.has(field) ? field : (numeric[0]?.path ?? '');
+    return { reducer, field: resolved, alias: 'value' };
+}
+function createDefaultEntityContract(entityName, available) {
+    return {
+        name: suggestedUserQueryName(entityName),
+        catalogTitle: entityName,
+        description: '',
+        kind: 'collection',
+        executionMode: 'backend',
+        columns: toColumnDefinitions(available),
+        capabilities: createDefaultContractCapabilities(available),
+        valueType: 'number',
+        measure: { ...DEFAULT_USER_QUERY_MEASURE },
+    };
+}
+function reconcileContractCapabilities(current, available, previousAvailablePaths = []) {
+    const defaults = createDefaultContractCapabilities(available);
+    if (!current) {
+        return defaults;
+    }
+    const availableByPath = new Map(available.map((field) => [field.path, field]));
+    const availablePaths = available.map((field) => field.path);
+    const availableSet = new Set(availablePaths);
+    const wasFilterAll = samePathSet(pathsFromFilterSection(current.filter), previousAvailablePaths);
+    const wasSortAll = samePathSet(pathsFromSortSection(current.sort), previousAvailablePaths);
+    const filterPaths = wasFilterAll
+        ? availablePaths
+        : pathsFromFilterSection(current.filter).filter((path) => availableSet.has(path));
+    const sortPaths = wasSortAll
+        ? availablePaths
+        : pathsFromSortSection(current.sort).filter((path) => availableSet.has(path));
+    const binding = reconcileBinding(current.binding, availableSet, defaults.binding);
+    return {
+        filter: toFilterSection(filterPaths.map((path) => availableByPath.get(path) ?? { path, text: path })),
+        sort: toSortSection(sortPaths.map((path) => availableByPath.get(path) ?? { path, text: path })),
+        paging: current.paging?.enabled
+            ? {
+                enabled: true,
+                definition: { ...AXP_QUERY_DEFAULT_COLLECTION_PAGING, ...(current.paging.definition ?? {}) },
+            }
+            : { enabled: false },
+        binding,
+    };
+}
+function assembleEntityQueryContract(identity, capabilities, selectedFields) {
+    const kind = normalizeUserQueryKind(identity.kind);
+    const nextCapabilities = capabilitiesForKind(kind, capabilities, selectedFields);
+    const contract = {
+        name: identity.name?.trim() ?? '',
+        catalogTitle: identity.catalogTitle?.trim() ?? '',
+        description: identity.description?.trim() || undefined,
+        kind,
+        executionMode: 'backend',
+        capabilities: nextCapabilities,
+    };
+    if (kind === 'value') {
+        return {
+            ...contract,
+            valueType: identity.valueType ? normalizeUserQueryValueType(identity.valueType) : 'number',
+            measure: normalizeUserQueryMeasure(identity.measure, selectedFields),
+        };
+    }
+    return {
+        ...contract,
+        columns: toColumnDefinitions(selectedFields),
+    };
+}
+function validateEntityQueryContract(contract, available) {
+    if (!contract?.name?.trim()) {
+        return 'name';
+    }
+    if (!contract.catalogTitle?.trim()) {
+        return 'title';
+    }
+    if (isValueQueryKind(contract.kind)) {
+        const measure = normalizeUserQueryMeasure(contract.measure, available);
+        if (measure.reducer !== 'count' && !measure.field) {
+            return 'measure';
+        }
+        return null;
+    }
+    if (!isCollectionQueryKind(contract.kind)) {
+        return null;
+    }
+    const paths = new Set(available.map((field) => field.path));
+    const binding = contract.capabilities?.binding;
+    if (!binding?.valueField || !binding.textField) {
+        return 'binding';
+    }
+    if (!paths.has(binding.valueField) || !paths.has(binding.textField)) {
+        return 'binding';
+    }
+    return null;
+}
+function formatContractCapabilitiesSummary(capabilities) {
+    if (!capabilities) {
+        return '';
+    }
+    const filterCount = pathsFromFilterSection(capabilities.filter).length;
+    const sortCount = pathsFromSortSection(capabilities.sort).length;
+    const paging = capabilities.paging?.enabled ? 'on' : 'off';
+    const binding = capabilities.binding
+        ? `${capabilities.binding.valueField}/${capabilities.binding.textField}`
+        : '';
+    return `filter ${filterCount}, sort ${sortCount}, paging ${paging}${binding ? `, ${binding}` : ''}`;
+}
+//#endregion
+//#region ----- Helpers -----
+function samePathSet(left, right) {
+    if (left.length !== right.length) {
+        return false;
+    }
+    const set = new Set(left);
+    return right.every((path) => set.has(path));
+}
+function reconcileBinding(current, availableSet, fallback) {
+    if (!current) {
+        return fallback;
+    }
+    const valueField = availableSet.has(current.valueField) ? current.valueField : fallback.valueField;
+    const textField = availableSet.has(current.textField) ? current.textField : fallback.textField;
+    return { valueField, textField };
+}
+function capabilitiesForKind(kind, current, available) {
+    const full = current ?? createDefaultContractCapabilities(available);
+    if (kind === 'collection') {
+        return full;
+    }
+    return {
+        filter: full.filter,
+        sort: { enabled: false },
+        paging: { enabled: false },
+        binding: full.binding,
+    };
+}
+//#endregion
+
+export { DEFAULT_USER_QUERY_PAGING as D, USER_QUERY_RELATED_DEPTH as U, resolveAvailableContractFields as a, assembleEntityQueryContract as b, collectSelectedFieldGroupPaths as c, collectUserQueryEntityFieldGroups as d, defaultSelectedFieldGroups as e, flattenEntityFieldItems as f, numericUserQueryFields as g, createDefaultEntityContract as h, pathsFromFilterSection as i, pathsFromSortSection as j, isCollectionQueryKind as k, reconcileContractCapabilities as l, toSortSection as m, normalizeUserQueryMeasure as n, createDefaultContractCapabilities as o, parseEntityFullName as p, formatContractCapabilitiesSummary as q, resolvePickedEntityFullName as r, selectedFieldPathsFromGroups as s, toFilterSection as t, validateEntityQueryContract as v, withRequiredIdField as w };
+//# sourceMappingURL=acorex-platform-module-platform-management-client-create-user-query-contract.util-D_af2BUi.mjs.map