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

package/fesm2022/acorex-platform-module-integration-management-client.mjs

@@ -0,0 +1,776 @@
+import { AXP_INTEGRATION_CONNECTION_STATUS, AXP_INTEGRATION_CONNECTION_SCOPE, AXP_INTEGRATION_CATEGORY, AXPIntegrationNotConnectedError, AXPIntegrationExpiredError, AXPIntegrationMissingScopeError } from '@acorex-platform/framework-shared/core';
+import { AXPSessionService, AXP_PERMISSION_DEFINITION_PROVIDER } from '@acorex-platform/framework-client/auth';
+import { AXPEntityService } from '@acorex-platform/framework-client/layout/entity';
+import * as i0 from '@angular/core';
+import { inject, Injectable, NgModule } from '@angular/core';
+import { isEmpty, trim, defaultTo } from 'lodash';
+import { RootConfig, AXPAdministrationPermissionKeys, AXMIntegrationManagementMenuKeys, AXMIntegrationManagementCommandKeys, AXMIntegrationManagementQueryKeys } from '@acorex-platform/module-integration-management-client/contracts';
+import { AXPIntegrationRuntimeService, AXPIntegrationProviderRegistryService, AXP_INTEGRATION_SECRET_STORE, AXP_INTEGRATION_RUNTIME_PROVIDER, AXP_PROTECTED_ROUTE_GUARDS, AXP_MENU_PROVIDER, AXP_SETTING_DEFINITION_PROVIDER, AXP_INTEGRATION_DOMAIN_PROVIDER } from '@acorex-platform/framework-client/common';
+import { AXP_MODULE_MANIFEST_PROVIDER, AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER } from '@acorex-platform/framework-client/core';
+import { AXPRuntimeModule, provideCommandSetups, provideQuerySetups } from '@acorex-platform/framework-client/runtime';
+import { CommonModule } from '@angular/common';
+import { ROUTES } from '@angular/router';
+import { AXPCommonMenuKeys, AXPCommonPermissionGroupKeys } from '@acorex-platform/module-common-client/contracts';
+import { firstValueFrom } from 'rxjs';
+import { AXPRootLayoutComponent } from '@acorex-platform/framework-client/themes/default';
+
+//#endregion
+
+//#region ---- Credential helpers ----
+const AXP_INTEGRATION_CREDENTIAL_MASK = '••••••••';
+function hasConfigCredential(config) {
+    return (!isEmpty(trim(String(config['apiKey'] ?? ''))) ||
+        !isEmpty(trim(String(config['accessToken'] ?? ''))) ||
+        !isEmpty(trim(String(config['refreshToken'] ?? ''))) ||
+        !isEmpty(trim(String(config['clientSecret'] ?? ''))) ||
+        !isEmpty(trim(String(config['botToken'] ?? ''))));
+}
+function isMaskedIntegrationCredential(value) {
+    const normalized = trim(value ?? '');
+    return !normalized || normalized === AXP_INTEGRATION_CREDENTIAL_MASK;
+}
+/** Clears runtime OAuth/token fields while keeping reconnect-friendly client settings. */
+function scrubDisconnectedConnectionConfig(config) {
+    if (!config) {
+        return null;
+    }
+    const next = { ...config };
+    delete next['accessToken'];
+    delete next['refreshToken'];
+    delete next['tokenExpiresAt'];
+    delete next['oauthTokenJson'];
+    delete next['authorizationUrl'];
+    delete next['token'];
+    delete next['password'];
+    delete next['apiToken'];
+    delete next['apiKey'];
+    delete next['botToken'];
+    return next;
+}
+function hasConfiguredIntegrationCredentials(connection) {
+    if (!connection || connection.status !== AXP_INTEGRATION_CONNECTION_STATUS.Connected) {
+        return false;
+    }
+    if (connection.isRevoked || connection.isDisabled) {
+        return false;
+    }
+    if (!isEmpty(trim(defaultTo(connection.secretRef, '')))) {
+        return true;
+    }
+    const config = (connection.config ?? {});
+    return hasConfigCredential(config);
+}
+//#endregion
+//#region ---- Safe mapper ----
+function toSafeIntegrationConnectionDto(connection) {
+    const secretRef = defaultTo(connection.secretRef, '');
+    const config = (connection.config ?? {});
+    const hasConfigSecret = hasConfigCredential(config);
+    const hasSecret = !isEmpty(trim(secretRef)) || hasConfigSecret;
+    return {
+        id: connection.id,
+        providerId: connection.providerId,
+        connectionScope: connection.connectionScope,
+        connectionKey: connection.connectionKey,
+        displayName: connection.displayName,
+        authMethodType: connection.authMethodType,
+        status: connection.status,
+        instanceUrl: connection.instanceUrl,
+        externalAccountId: connection.externalAccountId,
+        externalAccountName: connection.externalAccountName,
+        grantedScopes: connection.grantedScopes,
+        expiresAt: connection.expiresAt,
+        lastConnectedAt: connection.lastConnectedAt,
+        lastValidatedAt: connection.lastValidatedAt,
+        lastSyncAt: connection.lastSyncAt,
+        lastErrorCode: connection.lastErrorCode,
+        lastErrorMessage: connection.lastErrorMessage,
+        isRevoked: connection.isRevoked,
+        isDisabled: connection.isDisabled,
+        config: connection.config,
+        hasSecret,
+        secretPreview: hasSecret ? '••••••••' : null,
+    };
+}
+//#endregion
+//#region ---- Connection manager ----
+class AXMIntegrationConnectionManager {
+    constructor() {
+        //#region ---- Services & Dependencies ----
+        this.entityService = inject(AXPEntityService);
+        this.sessionService = inject(AXPSessionService);
+    }
+    //#endregion
+    //#region ---- Accessors ----
+    connectionAccessor() {
+        return this.entityService
+            .withEntity(RootConfig.module.name, RootConfig.entities.integrationConnection.name)
+            .data();
+    }
+    getSessionContext() {
+        const tenantId = this.sessionService.tenant?.id;
+        const applicationId = this.sessionService.application?.id;
+        const userId = this.sessionService.user?.id;
+        if (!tenantId || !applicationId || !userId) {
+            throw new Error('Integration operations require an authenticated user, tenant, and application context.');
+        }
+        return { tenantId, applicationId, userId };
+    }
+    ownershipFilters(tenantId, applicationId, userId) {
+        const filters = [
+            { field: 'scopeInfo.tenantId', operator: { type: 'equal' }, value: tenantId },
+            { field: 'scopeInfo.applicationId', operator: { type: 'equal' }, value: applicationId },
+        ];
+        if (userId) {
+            filters.push({ field: 'scopeInfo.userId', operator: { type: 'equal' }, value: userId });
+        }
+        return filters;
+    }
+    buildOwnershipInfo(tenantId, applicationId, connectionScope, userId) {
+        return {
+            tenantId,
+            applicationId,
+            ...(connectionScope === AXP_INTEGRATION_CONNECTION_SCOPE.User ? { userId } : {}),
+        };
+    }
+    //#endregion
+    //#region ---- Queries ----
+    async listForCurrentUser(connectionScope) {
+        const { tenantId, applicationId, userId } = this.getSessionContext();
+        const result = await this.connectionAccessor().query({
+            skip: 0,
+            take: 1000,
+            filter: {
+                logic: 'and',
+                filters: [
+                    ...this.ownershipFilters(tenantId, applicationId),
+                    ...(connectionScope
+                        ? [{ field: 'connectionScope', operator: { type: 'equal' }, value: connectionScope }]
+                        : []),
+                    {
+                        logic: 'or',
+                        filters: [
+                            {
+                                field: 'connectionScope',
+                                operator: { type: 'equal' },
+                                value: AXP_INTEGRATION_CONNECTION_SCOPE.Tenant,
+                            },
+                            {
+                                logic: 'and',
+                                filters: [
+                                    {
+                                        field: 'connectionScope',
+                                        operator: { type: 'equal' },
+                                        value: AXP_INTEGRATION_CONNECTION_SCOPE.User,
+                                    },
+                                    { field: 'scopeInfo.userId', operator: { type: 'equal' }, value: userId },
+                                ],
+                            },
+                        ],
+                    },
+                ],
+            },
+        });
+        return (result.items ?? []).filter((item) => {
+            if (item.connectionScope === AXP_INTEGRATION_CONNECTION_SCOPE.Tenant) {
+                return true;
+            }
+            return item.scopeInfo?.userId === userId;
+        });
+    }
+    async findByUniqueKey(input) {
+        const ctx = this.getSessionContext();
+        const tenantId = input.tenantId ?? ctx.tenantId;
+        const applicationId = input.applicationId ?? ctx.applicationId;
+        const userId = input.userId ?? ctx.userId;
+        const filters = [
+            ...this.ownershipFilters(tenantId, applicationId, input.connectionScope === AXP_INTEGRATION_CONNECTION_SCOPE.User ? userId : undefined),
+            { field: 'providerId', operator: { type: 'equal' }, value: input.providerId },
+            { field: 'connectionScope', operator: { type: 'equal' }, value: input.connectionScope },
+            { field: 'connectionKey', operator: { type: 'equal' }, value: input.connectionKey },
+        ];
+        const result = await this.connectionAccessor().query({
+            skip: 0,
+            take: 1,
+            filter: { logic: 'and', filters },
+        });
+        return result.items?.[0] ?? null;
+    }
+    async getByIdForCurrentUser(connectionId) {
+        const connection = await this.connectionAccessor().byKey(connectionId);
+        if (!connection) {
+            return null;
+        }
+        return this.assertOwnership(connection) ? connection : null;
+    }
+    //#endregion
+    //#region ---- Mutations ----
+    async upsertConnection(data) {
+        const { tenantId, applicationId, userId } = this.getSessionContext();
+        const existing = await this.findByUniqueKey({
+            providerId: data.providerId,
+            connectionScope: data.connectionScope,
+            connectionKey: data.connectionKey,
+            tenantId,
+            applicationId,
+            userId: data.connectionScope === AXP_INTEGRATION_CONNECTION_SCOPE.User ? userId : undefined,
+        });
+        const scopeInfo = this.buildOwnershipInfo(tenantId, applicationId, data.connectionScope, userId);
+        const payload = {
+            ...data,
+            scopeInfo,
+            isRevoked: defaultTo(data.isRevoked, false),
+            isDisabled: defaultTo(data.isDisabled, false),
+            status: data.status ?? AXP_INTEGRATION_CONNECTION_STATUS.Connected,
+            lastConnectedAt: data.lastConnectedAt ?? new Date().toISOString(),
+        };
+        if (existing) {
+            await this.connectionAccessor().update(existing.id, payload);
+            const updated = await this.connectionAccessor().byKey(existing.id);
+            if (!updated) {
+                throw new Error('Connection not found after update.');
+            }
+            return updated;
+        }
+        const createPayload = {
+            providerId: data.providerId,
+            connectionScope: data.connectionScope,
+            connectionKey: data.connectionKey,
+            displayName: data.displayName,
+            authMethodType: data.authMethodType,
+            scopeInfo,
+            isRevoked: defaultTo(data.isRevoked, false),
+            isDisabled: defaultTo(data.isDisabled, false),
+            status: data.status ?? AXP_INTEGRATION_CONNECTION_STATUS.Connected,
+            lastConnectedAt: data.lastConnectedAt ?? new Date().toISOString(),
+            instanceUrl: data.instanceUrl ?? null,
+            externalAccountId: data.externalAccountId ?? null,
+            externalAccountName: data.externalAccountName ?? null,
+            grantedScopes: data.grantedScopes ?? null,
+            secretRef: data.secretRef ?? null,
+            expiresAt: data.expiresAt ?? null,
+            lastValidatedAt: data.lastValidatedAt ?? null,
+            lastSyncAt: data.lastSyncAt ?? null,
+            lastErrorCode: data.lastErrorCode ?? null,
+            lastErrorMessage: data.lastErrorMessage ?? null,
+            config: data.config ?? null,
+        };
+        const id = await this.connectionAccessor().create(createPayload);
+        const created = await this.connectionAccessor().byKey(id);
+        if (!created) {
+            throw new Error('Connection not found after create.');
+        }
+        return created;
+    }
+    async updateConnection(connectionId, patch) {
+        const existing = await this.getByIdForCurrentUser(connectionId);
+        if (!existing) {
+            throw new Error('Connection not found or access denied.');
+        }
+        await this.connectionAccessor().update(connectionId, patch);
+        const updated = await this.connectionAccessor().byKey(connectionId);
+        if (!updated) {
+            throw new Error('Connection not found after update.');
+        }
+        return updated;
+    }
+    async deleteConnection(connectionId) {
+        const existing = await this.getByIdForCurrentUser(connectionId);
+        if (!existing) {
+            throw new Error('Connection not found or access denied.');
+        }
+        await this.connectionAccessor().delete(connectionId);
+    }
+    //#endregion
+    //#region ---- Authorization ----
+    assertOwnership(connection) {
+        const { tenantId, applicationId, userId } = this.getSessionContext();
+        if (connection.scopeInfo?.tenantId !== tenantId) {
+            return false;
+        }
+        if (connection.scopeInfo?.applicationId !== applicationId) {
+            return false;
+        }
+        if (connection.connectionScope === AXP_INTEGRATION_CONNECTION_SCOPE.Tenant) {
+            return true;
+        }
+        return connection.scopeInfo?.userId === userId;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMIntegrationConnectionManager, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMIntegrationConnectionManager, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMIntegrationConnectionManager, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+const IntegrationManagementManifest = {
+    name: RootConfig.module.name,
+    version: '1.0.0',
+    title: RootConfig.module.title,
+    icon: RootConfig.module.icon,
+    i18n: RootConfig.config.i18n,
+    type: 'platform',
+    domain: 'platform',
+    required: false,
+};
+
+//#region ----- Imports -----
+//#endregion
+//#region ----- Menu Provider -----
+class AXMIntegrationManagementMenuProvider {
+    constructor() {
+        this.sessionService = inject(AXPSessionService);
+    }
+    async provide(context) {
+        const isAuthorized = await firstValueFrom(this.sessionService.isAuthorized$);
+        if (!isAuthorized) {
+            return;
+        }
+        const appName = this.sessionService.application?.name;
+        context.find(AXPCommonMenuKeys.Administration).addItems([
+            {
+                name: AXMIntegrationManagementMenuKeys.Integrations,
+                priority: 1000,
+                text: '@integration-management:pages.integrations.title',
+                type: 'menu',
+                icon: 'fa-light fa-plug',
+                path: `/${appName}/admin/integrations`,
+                policy: {
+                    features: [RootConfig.module.name],
+                    permissions: [AXPAdministrationPermissionKeys.MaintainConnections],
+                },
+            },
+        ]);
+    }
+}
+//#endregion
+
+//#endregion
+//#region ---- Permission Definition Provider ----
+/**
+ * Registers Integrations section capabilities under Administration.
+ */
+class AXMIntegrationManagementPermissionDefinitionProvider {
+    async define(context) {
+        const keys = AXPAdministrationPermissionKeys;
+        const groups = AXPCommonPermissionGroupKeys;
+        const P = '@common:administration.permissions';
+        const G = '@common:permission-groups';
+        context.addGroup(groups.Administration.Root, `${G}.administration.title`, `${G}.administration.description`, { order: 120 });
+        context
+            .addGroup(groups.Administration.Integrations, `${G}.administration-integrations.title`, `${G}.administration-integrations.description`, { parent: groups.Administration.Root, order: 20 })
+            .addPermission(keys.ViewIntegrations, `${P}.view-integrations.title`, `${P}.view-integrations.description`)
+            .endPermission()
+            .addPermission(keys.MaintainConnections, `${P}.maintain-connections.title`, `${P}.maintain-connections.description`)
+            .endPermission()
+            .addPermission(keys.ManageIntegrationActions, `${P}.manage-integration-actions.title`, `${P}.manage-integration-actions.description`)
+            .endPermission()
+            .endGroup();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMIntegrationManagementPermissionDefinitionProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMIntegrationManagementPermissionDefinitionProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMIntegrationManagementPermissionDefinitionProvider, decorators: [{
+            type: Injectable
+        }] });
+
+//#region ---- Imports ----
+//#endregion
+//#region ---- Settings Provider ----
+const I18N$1 = '@integration-management:settings';
+class AXMIntegrationManagementSettingProvider {
+    async provide(context) {
+        if (context.hasGroup('integrations')) {
+            return;
+        }
+        context
+            .addGroup('integrations', `${I18N$1}.group.nav-title`, `${I18N$1}.group.description`, 'fa-light fa-plug', `${I18N$1}.group.title`, 45)
+            .endGroup();
+    }
+}
+//#endregion
+
+const I18N = '@integration-management:settings.domains.other';
+/** Fallback domain for connectors not yet assigned to a first-class integration domain. */
+class AXMIntegrationLegacyDomainProvider {
+    async provide(context) {
+        context.register({
+            id: 'other',
+            module: RootConfig.module.name,
+            displayName: `${I18N}.title`,
+            description: `${I18N}.description`,
+            icon: 'fa-light fa-plug',
+            category: AXP_INTEGRATION_CATEGORY.Other,
+            capabilities: [],
+            sortOrder: 999,
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMIntegrationLegacyDomainProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMIntegrationLegacyDomainProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMIntegrationLegacyDomainProvider, decorators: [{
+            type: Injectable
+        }] });
+
+//#region ---- Runtime service implementation ----
+class AXMIntegrationRuntimeServiceImpl extends AXPIntegrationRuntimeService {
+    constructor() {
+        super(...arguments);
+        this.registry = inject(AXPIntegrationProviderRegistryService);
+        this.connectionManager = inject(AXMIntegrationConnectionManager);
+        this.secretStore = inject(AXP_INTEGRATION_SECRET_STORE, { optional: true });
+        this.runtimeProviders = inject(AXP_INTEGRATION_RUNTIME_PROVIDER, { optional: true });
+    }
+    async getProvider(id) {
+        return this.registry.getOrThrow(id);
+    }
+    async listProviders() {
+        return this.registry.list();
+    }
+    async getConnection(options) {
+        const connection = await this.resolveConnection(options);
+        return toSafeIntegrationConnectionDto(connection);
+    }
+    async withClient(options, fn) {
+        const connection = await this.resolveConnection(options);
+        if (!connection.secretRef) {
+            throw new AXPIntegrationNotConnectedError(options.providerId);
+        }
+        const ctx = await this.buildRuntimeContext({
+            ...toSafeIntegrationConnectionDto(connection),
+            secretRef: connection.secretRef,
+        });
+        const hooks = await this.resolveRuntimeHooks(options.providerId);
+        if (!hooks?.createClient) {
+            throw new Error(`Integration provider '${options.providerId}' does not expose a runtime client.`);
+        }
+        const client = await hooks.createClient(ctx);
+        return fn(client, ctx);
+    }
+    async buildRuntimeContext(connection) {
+        const { tenantId, applicationId, userId } = this.connectionManager.getSessionContext();
+        return {
+            tenantId,
+            applicationId,
+            userId,
+            connectionId: connection.id,
+            providerId: connection.providerId,
+            connectionScope: connection.connectionScope,
+            connectionKey: connection.connectionKey,
+            authMethodType: connection.authMethodType,
+            instanceUrl: connection.instanceUrl,
+            config: connection.config,
+            secretRef: connection.secretRef,
+        };
+    }
+    async resolveConnection(options) {
+        const provider = await this.registry.getOrThrow(options.providerId);
+        const connectionScope = options.connectionScope ?? 'user';
+        const connectionKey = defaultTo(options.connectionKey, provider.defaultConnectionKey ?? 'default');
+        if (options.requiredCapabilities?.length) {
+            const missing = options.requiredCapabilities.filter((c) => !provider.capabilities.includes(c));
+            if (missing.length) {
+                throw new Error(`Provider '${provider.id}' is missing capabilities: ${missing.join(', ')}`);
+            }
+        }
+        const connection = await this.connectionManager.findByUniqueKey({
+            providerId: options.providerId,
+            connectionScope,
+            connectionKey,
+        });
+        if (!connection || connection.status !== AXP_INTEGRATION_CONNECTION_STATUS.Connected) {
+            throw new AXPIntegrationNotConnectedError(options.providerId);
+        }
+        if (connection.expiresAt && new Date(connection.expiresAt).getTime() < Date.now()) {
+            throw new AXPIntegrationExpiredError(options.providerId, connection.id);
+        }
+        if (options.requiredScopes?.length && connection.grantedScopes) {
+            const missingScopes = options.requiredScopes.filter((s) => !connection.grantedScopes.includes(s));
+            if (!isEmpty(missingScopes)) {
+                throw new AXPIntegrationMissingScopeError(options.providerId, missingScopes);
+            }
+        }
+        return connection;
+    }
+    async resolveRuntimeHooks(providerId) {
+        const providers = this.runtimeProviders ?? [];
+        for (const provider of providers) {
+            const resolved = provider instanceof Promise ? await provider : provider;
+            if (resolved.providerId === providerId) {
+                return resolved.getHooks();
+            }
+        }
+        return null;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMIntegrationRuntimeServiceImpl, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMIntegrationRuntimeServiceImpl, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMIntegrationRuntimeServiceImpl, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+//#region ---- Integration connection status ----
+/** Matches integration-connections-panel `isProviderConnected` semantics. */
+function isActiveIntegrationConnection(connection) {
+    if (!connection) {
+        return false;
+    }
+    return (connection.status === AXP_INTEGRATION_CONNECTION_STATUS.Connected &&
+        !connection.isRevoked &&
+        !connection.isDisabled);
+}
+//#endregion
+
+//#region ---- Integration expression scope ----
+/**
+ * Exposes integration connection checks in expression strings, e.g.
+ * `{{ integration.isUserConnected('telegram') }}`.
+ */
+class AXMIntegrationEvaluatorScopeProvider {
+    constructor() {
+        this.connectionManager = inject(AXMIntegrationConnectionManager);
+    }
+    async provide(context) {
+        context.addScope('integration', {
+            isUserConnected: (providerId, connectionKey) => this.isConnected(providerId, AXP_INTEGRATION_CONNECTION_SCOPE.User, connectionKey),
+            isTenantConfigured: (providerId, connectionKey) => this.isConnected(providerId, AXP_INTEGRATION_CONNECTION_SCOPE.Tenant, connectionKey),
+        });
+    }
+    async isConnected(providerId, scope, connectionKey) {
+        const normalizedProviderId = String(providerId ?? '').trim();
+        if (!normalizedProviderId) {
+            return false;
+        }
+        const connection = await this.connectionManager.findByUniqueKey({
+            providerId: normalizedProviderId,
+            connectionScope: scope,
+            connectionKey: defaultTo(connectionKey, 'default'),
+        });
+        return isActiveIntegrationConnection(connection);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMIntegrationEvaluatorScopeProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMIntegrationEvaluatorScopeProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMIntegrationEvaluatorScopeProvider, decorators: [{
+            type: Injectable
+        }] });
+
+//#region ----- Imports -----
+//#endregion
+//#region ----- Routes -----
+function integrationManagementRoutesFactory() {
+    return [
+        {
+            path: ':app/admin/integrations',
+            canActivate: [...AXP_PROTECTED_ROUTE_GUARDS],
+            data: { tab: true, rootLayout: true },
+            loadComponent: () => AXPRootLayoutComponent,
+            children: [
+                {
+                    path: '',
+                    loadComponent: () => import('./acorex-platform-module-integration-management-client-integrations-page.component-Q-SHidYA.mjs').then((c) => c.AXMIntegrationsPageComponent),
+                    data: { reuse: true },
+                },
+            ],
+        },
+    ];
+}
+//#endregion
+
+const integrationOAuthCallbackRoutes = [
+    // App-agnostic callback first — must win over `:appName/...` (else appName="integrations").
+    {
+        path: 'integrations/oauth/callback/:providerId',
+        loadComponent: () => import('./acorex-platform-module-integration-management-client-integration-oauth-callback-page.component-XhloXUsZ.mjs').then((c) => c.AXMIntegrationOAuthCallbackPageComponent),
+    },
+    // Legacy app-prefixed callback (older provider redirect URI configs).
+    {
+        path: ':appName/integrations/oauth/callback/:providerId',
+        loadComponent: () => import('./acorex-platform-module-integration-management-client-integration-oauth-callback-page.component-XhloXUsZ.mjs').then((c) => c.AXMIntegrationOAuthCallbackPageComponent),
+    },
+];
+
+//#region ---- Imports ----
+//#endregion
+//#region ---- Module ----
+class AXMIntegrationManagementModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMIntegrationManagementModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "22.0.8", ngImport: i0, type: AXMIntegrationManagementModule, imports: [CommonModule, AXPRuntimeModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMIntegrationManagementModule, providers: [
+            {
+                provide: ROUTES,
+                multi: true,
+                useFactory: () => [...integrationManagementRoutesFactory(), ...integrationOAuthCallbackRoutes],
+            },
+            {
+                provide: AXP_MODULE_MANIFEST_PROVIDER,
+                useValue: IntegrationManagementManifest,
+                multi: true,
+            },
+            {
+                provide: AXP_PERMISSION_DEFINITION_PROVIDER,
+                useClass: AXMIntegrationManagementPermissionDefinitionProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_MENU_PROVIDER,
+                useClass: AXMIntegrationManagementMenuProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_SETTING_DEFINITION_PROVIDER,
+                useClass: AXMIntegrationManagementSettingProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_INTEGRATION_DOMAIN_PROVIDER,
+                useClass: AXMIntegrationLegacyDomainProvider,
+                multi: true,
+            },
+            {
+                provide: AXPIntegrationRuntimeService,
+                useClass: AXMIntegrationRuntimeServiceImpl,
+            },
+            {
+                provide: AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER,
+                useClass: AXMIntegrationEvaluatorScopeProvider,
+                multi: true,
+            },
+            provideCommandSetups([
+                {
+                    key: AXMIntegrationManagementCommandKeys.ConnectionConnectWithCredentials,
+                    command: () => import('./acorex-platform-module-integration-management-client-connect-with-credentials.command-DO_zqjHV.mjs').then((c) => c.ConnectWithCredentialsCommand),
+                },
+                {
+                    key: AXMIntegrationManagementCommandKeys.ConnectionDisconnect,
+                    command: () => import('./acorex-platform-module-integration-management-client-disconnect-connection.command-B4HeDA1n.mjs').then((c) => c.DisconnectConnectionCommand),
+                },
+                {
+                    key: AXMIntegrationManagementCommandKeys.ConnectionDelete,
+                    command: () => import('./acorex-platform-module-integration-management-client-delete-connection.command-DQ_kn8dH.mjs').then((c) => c.DeleteConnectionCommand),
+                },
+                {
+                    key: AXMIntegrationManagementCommandKeys.ConnectionUpdate,
+                    command: () => import('./acorex-platform-module-integration-management-client-update-connection.command-BNMR-t12.mjs').then((c) => c.UpdateConnectionCommand),
+                },
+                {
+                    key: AXMIntegrationManagementCommandKeys.ConnectionValidate,
+                    command: () => import('./acorex-platform-module-integration-management-client-validate-connection.command-CGtb_GPX.mjs').then((c) => c.ValidateConnectionCommand),
+                },
+            ]),
+            provideQuerySetups([
+                {
+                    key: AXMIntegrationManagementQueryKeys.DomainList,
+                    loader: () => import('./acorex-platform-module-integration-management-client-list-domains.query--GGD6J46.mjs').then((c) => c.ListDomainsQuery),
+                },
+                {
+                    key: AXMIntegrationManagementQueryKeys.ProviderList,
+                    loader: () => import('./acorex-platform-module-integration-management-client-list-providers.query-ODKJ_UhI.mjs').then((c) => c.ListProvidersQuery),
+                },
+                {
+                    key: AXMIntegrationManagementQueryKeys.ProviderGet,
+                    loader: () => import('./acorex-platform-module-integration-management-client-get-provider.query-Ds10RwnU.mjs').then((c) => c.GetProviderQuery),
+                },
+                {
+                    key: AXMIntegrationManagementQueryKeys.ConnectionListMine,
+                    loader: () => import('./acorex-platform-module-integration-management-client-list-my-connections.query-CmHu1qFm.mjs').then((c) => c.ListMyConnectionsQuery),
+                },
+            ]),
+        ], imports: [CommonModule, AXPRuntimeModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMIntegrationManagementModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule, AXPRuntimeModule],
+                    providers: [
+                        {
+                            provide: ROUTES,
+                            multi: true,
+                            useFactory: () => [...integrationManagementRoutesFactory(), ...integrationOAuthCallbackRoutes],
+                        },
+                        {
+                            provide: AXP_MODULE_MANIFEST_PROVIDER,
+                            useValue: IntegrationManagementManifest,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_PERMISSION_DEFINITION_PROVIDER,
+                            useClass: AXMIntegrationManagementPermissionDefinitionProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_MENU_PROVIDER,
+                            useClass: AXMIntegrationManagementMenuProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_SETTING_DEFINITION_PROVIDER,
+                            useClass: AXMIntegrationManagementSettingProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_INTEGRATION_DOMAIN_PROVIDER,
+                            useClass: AXMIntegrationLegacyDomainProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXPIntegrationRuntimeService,
+                            useClass: AXMIntegrationRuntimeServiceImpl,
+                        },
+                        {
+                            provide: AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER,
+                            useClass: AXMIntegrationEvaluatorScopeProvider,
+                            multi: true,
+                        },
+                        provideCommandSetups([
+                            {
+                                key: AXMIntegrationManagementCommandKeys.ConnectionConnectWithCredentials,
+                                command: () => import('./acorex-platform-module-integration-management-client-connect-with-credentials.command-DO_zqjHV.mjs').then((c) => c.ConnectWithCredentialsCommand),
+                            },
+                            {
+                                key: AXMIntegrationManagementCommandKeys.ConnectionDisconnect,
+                                command: () => import('./acorex-platform-module-integration-management-client-disconnect-connection.command-B4HeDA1n.mjs').then((c) => c.DisconnectConnectionCommand),
+                            },
+                            {
+                                key: AXMIntegrationManagementCommandKeys.ConnectionDelete,
+                                command: () => import('./acorex-platform-module-integration-management-client-delete-connection.command-DQ_kn8dH.mjs').then((c) => c.DeleteConnectionCommand),
+                            },
+                            {
+                                key: AXMIntegrationManagementCommandKeys.ConnectionUpdate,
+                                command: () => import('./acorex-platform-module-integration-management-client-update-connection.command-BNMR-t12.mjs').then((c) => c.UpdateConnectionCommand),
+                            },
+                            {
+                                key: AXMIntegrationManagementCommandKeys.ConnectionValidate,
+                                command: () => import('./acorex-platform-module-integration-management-client-validate-connection.command-CGtb_GPX.mjs').then((c) => c.ValidateConnectionCommand),
+                            },
+                        ]),
+                        provideQuerySetups([
+                            {
+                                key: AXMIntegrationManagementQueryKeys.DomainList,
+                                loader: () => import('./acorex-platform-module-integration-management-client-list-domains.query--GGD6J46.mjs').then((c) => c.ListDomainsQuery),
+                            },
+                            {
+                                key: AXMIntegrationManagementQueryKeys.ProviderList,
+                                loader: () => import('./acorex-platform-module-integration-management-client-list-providers.query-ODKJ_UhI.mjs').then((c) => c.ListProvidersQuery),
+                            },
+                            {
+                                key: AXMIntegrationManagementQueryKeys.ProviderGet,
+                                loader: () => import('./acorex-platform-module-integration-management-client-get-provider.query-Ds10RwnU.mjs').then((c) => c.GetProviderQuery),
+                            },
+                            {
+                                key: AXMIntegrationManagementQueryKeys.ConnectionListMine,
+                                loader: () => import('./acorex-platform-module-integration-management-client-list-my-connections.query-CmHu1qFm.mjs').then((c) => c.ListMyConnectionsQuery),
+                            },
+                        ]),
+                    ],
+                }]
+        }] });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AXMIntegrationConnectionManager, AXMIntegrationManagementModule, AXP_INTEGRATION_CREDENTIAL_MASK, IntegrationManagementManifest, hasConfiguredIntegrationCredentials, isMaskedIntegrationCredential, scrubDisconnectedConnectionConfig, toSafeIntegrationConnectionDto };
+//# sourceMappingURL=acorex-platform-module-integration-management-client.mjs.map