@wildo-ai/saas-backend-lib 1.0.1

package/dist/esm/features/services/feature-gate.backend.service.js

@@ -0,0 +1,414 @@
+/**
+ * Feature Gate Backend Service
+ *
+ * Enforces feature availability checks before operations execute.
+ *
+ * Two-phase check:
+ * - Phase 1: Boolean features (presence check with OR/AND mode)
+ * - Phase 2: Limit checks (capacity check with counting queries + increment inference)
+ *
+ * Bypasses:
+ * - INTERNALLY_INITIATED_REQUEST execution type (system calls)
+ * - PUBLIC_EXECUTION execution type (login, registration — defaults-only features)
+ * - REPOSITORY_ONLY and INTERNAL_CALL operation variant types
+ * - System resources (isSystemResource === true)
+ *
+ * This service is the single authoritative enforcement point.
+ * Integration into the operation pipeline is done in T1.10.
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { injectable, inject } from 'inversify';
+import { FEATURES_UNLIMITED, FeatureValueType, CoreResourceOperation, ErrorType, ErrorCustomMessageReference, ExecutionContext_ExecutionType, ResourceOperationVariantType, } from '@wildo-ai/saas-models';
+import { SAAS_SERVICE_TYPES } from '../../inject/models/service-types.js';
+// =====================================================
+// Feature Gate Service
+// =====================================================
+let FeatureGateBackendService = class FeatureGateBackendService {
+    logger;
+    errorBuilder;
+    featureRegistry;
+    featureResolution;
+    repositoriesRegistry;
+    logDebug;
+    constructor(logger, errorBuilder, featureRegistry, featureResolution, repositoriesRegistry) {
+        this.logger = logger;
+        this.errorBuilder = errorBuilder;
+        this.featureRegistry = featureRegistry;
+        this.featureResolution = featureResolution;
+        this.repositoriesRegistry = repositoriesRegistry;
+        this.logDebug = this.logger.debugByType('FeatureGateBackendService');
+    }
+    // ─────────────────────────────────────────────────────────────
+    // Public API
+    // ─────────────────────────────────────────────────────────────
+    /**
+     * Check if operation's requiredFeatures are met.
+     * Uses resolved features from the resolution service.
+     *
+     * Two-phase check:
+     * Phase 1 - Boolean features (features[]): presence check with OR/AND mode
+     * Phase 2 - Limit checks (limitChecks[]): capacity check with counting + increment
+     *
+     * @param operation - The operation being executed
+     * @param executionContext - Current execution context
+     * @param validatedData - The validated request body (used to infer increment for batch operations)
+     * @throws FEATURE_NOT_AVAILABLE if a required boolean feature is not enabled
+     * @throws FEATURE_LIMIT_EXCEEDED if a limit would be exceeded
+     */
+    async checkOperationFeatures(operation, executionContext, validatedData) {
+        // ── Bypass conditions ──
+        if (this.shouldBypass(operation, executionContext)) {
+            return;
+        }
+        const requiredFeatures = operation.requiredFeatures;
+        if (!requiredFeatures) {
+            return; // No features required for this operation
+        }
+        // Use precomputed features if available, otherwise resolve
+        let resolvedFeatures = executionContext.resolvedFeatures;
+        if (!resolvedFeatures) {
+            resolvedFeatures = await this.featureResolution.resolve(executionContext);
+            executionContext.setResolvedFeatures(resolvedFeatures);
+        }
+        this.logDebug('Checking operation features', {
+            operationId: operation.operationIdentifier,
+            resource: operation.resourceIdentifier,
+            requiredBooleanCount: requiredFeatures.features?.length ?? 0,
+            requiredLimitCount: requiredFeatures.limitChecks?.length ?? 0,
+        });
+        // ── Phase 1: Boolean features ──
+        this.checkBooleanFeatures(requiredFeatures, resolvedFeatures, executionContext);
+        // ── Phase 2: Limit checks ──
+        if (requiredFeatures.limitChecks && requiredFeatures.limitChecks.length > 0) {
+            await this.checkLimitFeatures(requiredFeatures.limitChecks, resolvedFeatures, executionContext, operation.operationIdentifier, validatedData);
+        }
+    }
+    /**
+     * Enforce a standalone requiredFeatures contract outside the resource-operation
+     * pipeline, for example on manual controller seams such as chart execution.
+     */
+    async checkRequiredFeatures(requiredFeatures, executionContext, params) {
+        if (!requiredFeatures
+            || executionContext.executionType === ExecutionContext_ExecutionType.INTERNALLY_INITIATED_REQUEST
+            || executionContext.executionType === ExecutionContext_ExecutionType.PUBLIC_EXECUTION) {
+            return;
+        }
+        const normalizedRequiredFeatures = Array.isArray(requiredFeatures)
+            ? { features: requiredFeatures }
+            : requiredFeatures;
+        let resolvedFeatures = executionContext.resolvedFeatures;
+        if (!resolvedFeatures) {
+            resolvedFeatures = await this.featureResolution.resolve(executionContext);
+            executionContext.setResolvedFeatures(resolvedFeatures);
+        }
+        this.logDebug('Checking standalone requiredFeatures', {
+            identifier: params?.identifier ?? 'standalone-required-features',
+            requiredBooleanCount: normalizedRequiredFeatures.features?.length ?? 0,
+            requiredLimitCount: normalizedRequiredFeatures.limitChecks?.length ?? 0,
+        });
+        this.checkBooleanFeatures(normalizedRequiredFeatures, resolvedFeatures, executionContext);
+        if (normalizedRequiredFeatures.limitChecks && normalizedRequiredFeatures.limitChecks.length > 0) {
+            await this.checkLimitFeatures(normalizedRequiredFeatures.limitChecks, resolvedFeatures, executionContext, params?.identifier ?? 'standalone-required-features', params?.validatedData);
+        }
+    }
+    /**
+     * Standalone limit check (for custom service code).
+     * Can be called directly when the developer needs more control.
+     * Returns current status on success.
+     *
+     * Unlike the automatic operation gate, this helper must not invent a usable
+     * remaining quota when no counting config exists. Callers either provide an
+     * explicit override or rely on a feature definition that defines counting.
+     *
+     * @throws FEATURE_LIMIT_EXCEEDED if limit would be exceeded
+     */
+    async checkLimit(featureId, executionContext, increment, countingOverride) {
+        const resolvedFeatures = await this.featureResolution.resolve(executionContext);
+        const limit = resolvedFeatures.limits[featureId];
+        // No limit set or unlimited → always pass
+        if (limit === undefined || limit === FEATURES_UNLIMITED) {
+            return {
+                currentUsage: 0,
+                limit: limit ?? FEATURES_UNLIMITED,
+                remaining: FEATURES_UNLIMITED,
+            };
+        }
+        const countingConfig = countingOverride ?? this.featureRegistry.getDefinition(featureId)?.counting;
+        if (!countingConfig) {
+            throw this.errorBuilder.buildError(ErrorType.VALIDATION, executionContext, {
+                context: {
+                    featureId,
+                    reason: 'Missing counting config for limit feature check',
+                },
+            });
+        }
+        const actualIncrement = increment ?? 0;
+        const currentUsage = await this.executeCountingQuery(countingConfig, executionContext);
+        if (currentUsage + actualIncrement > limit) {
+            throw this.errorBuilder.buildError(ErrorType.FEATURE_LIMIT_EXCEEDED, executionContext, {
+                customMessageReference: ErrorCustomMessageReference.FEATURE_LIMIT_EXCEEDED,
+                context: {
+                    featureId,
+                    current: currentUsage,
+                    limit,
+                    increment: actualIncrement,
+                },
+            });
+        }
+        return {
+            currentUsage,
+            limit,
+            remaining: limit - currentUsage,
+        };
+    }
+    /**
+     * Get current usage for a limit feature (for frontend/dashboard).
+     * Returns the count/aggregate based on the feature's counting config.
+     * Returns undefined if no counting config is defined.
+     */
+    async getCurrentUsage(featureId, executionContext) {
+        const def = this.featureRegistry.getDefinition(featureId);
+        if (!def?.counting)
+            return undefined;
+        return this.executeCountingQuery(def.counting, executionContext);
+    }
+    // ─────────────────────────────────────────────────────────────
+    // Phase 1: Boolean Features
+    // ─────────────────────────────────────────────────────────────
+    /**
+     * Check boolean features with OR/AND mode.
+     * OR mode: any single enabled feature is enough (short-circuit pass)
+     * AND mode: all features must be enabled (short-circuit fail)
+     */
+    checkBooleanFeatures(requiredFeatures, resolvedFeatures, executionContext) {
+        const features = requiredFeatures.features;
+        if (!features || features.length === 0)
+            return;
+        const mode = requiredFeatures.mode ?? 'OR';
+        const resolvedSet = new Set(resolvedFeatures.features);
+        if (mode === 'OR') {
+            // OR: at least one must be enabled
+            const anyEnabled = features.some(featureId => {
+                const def = this.featureRegistry.getDefinition(featureId);
+                // Only check boolean features in Phase 1 (limit features are Phase 2)
+                if (def && def.valueType !== FeatureValueType.BOOLEAN)
+                    return false;
+                return resolvedSet.has(featureId);
+            });
+            if (!anyEnabled) {
+                this.logDebug('OR-mode feature check failed — none enabled', { features });
+                throw this.errorBuilder.buildError(ErrorType.FEATURE_NOT_AVAILABLE, executionContext, {
+                    customMessageReference: ErrorCustomMessageReference.FEATURE_NOT_AVAILABLE,
+                    context: { features, mode },
+                });
+            }
+        }
+        else {
+            // AND: all must be enabled
+            for (const featureId of features) {
+                const def = this.featureRegistry.getDefinition(featureId);
+                // Only check boolean features in Phase 1
+                if (def && def.valueType !== FeatureValueType.BOOLEAN)
+                    continue;
+                if (!resolvedSet.has(featureId)) {
+                    this.logDebug('AND-mode feature check failed', { featureId, features });
+                    throw this.errorBuilder.buildError(ErrorType.FEATURE_NOT_AVAILABLE, executionContext, {
+                        customMessageReference: ErrorCustomMessageReference.FEATURE_NOT_AVAILABLE,
+                        context: { features: [featureId], mode },
+                    });
+                }
+            }
+        }
+    }
+    // ─────────────────────────────────────────────────────────────
+    // Phase 2: Limit Features
+    // ─────────────────────────────────────────────────────────────
+    /**
+     * Check limit features — all must pass (always AND logic).
+     */
+    async checkLimitFeatures(limitChecks, resolvedFeatures, executionContext, operationIdentifier, validatedData) {
+        for (const check of limitChecks) {
+            const limit = resolvedFeatures.limits[check.featureId];
+            // FEATURES_UNLIMITED → always pass
+            if (limit === FEATURES_UNLIMITED) {
+                this.logDebug('Limit check skipped — unlimited', { featureId: check.featureId });
+                continue;
+            }
+            // No limit set → no restriction
+            if (limit === undefined) {
+                this.logDebug('Limit check skipped — no limit set', { featureId: check.featureId });
+                continue;
+            }
+            // Determine counting config
+            const countingConfig = check.countingOverride
+                ?? this.featureRegistry.getDefinition(check.featureId)?.counting;
+            if (!countingConfig) {
+                throw this.errorBuilder.buildError(ErrorType.VALIDATION, executionContext, {
+                    context: {
+                        featureId: check.featureId,
+                        reason: 'Missing counting config for limit feature check',
+                    },
+                });
+            }
+            // Determine increment
+            const increment = check.increment !== undefined
+                ? check.increment
+                : this.inferIncrement(operationIdentifier, validatedData);
+            // Execute counting query
+            const currentUsage = await this.executeCountingQuery(countingConfig, executionContext);
+            this.logDebug('Limit check', {
+                featureId: check.featureId,
+                currentUsage,
+                limit,
+                increment,
+                wouldExceed: currentUsage + increment > limit,
+            });
+            if (currentUsage + increment > limit) {
+                throw this.errorBuilder.buildError(ErrorType.FEATURE_LIMIT_EXCEEDED, executionContext, {
+                    customMessageReference: ErrorCustomMessageReference.FEATURE_LIMIT_EXCEEDED,
+                    context: {
+                        featureId: check.featureId,
+                        current: currentUsage,
+                        limit,
+                        increment,
+                    },
+                });
+            }
+        }
+    }
+    // ─────────────────────────────────────────────────────────────
+    // Counting Query Execution
+    // ─────────────────────────────────────────────────────────────
+    /**
+     * Execute a counting query using the repository infrastructure.
+     *
+     * IMPORTANT: Does NOT add manual scope filters. The repository's count()/aggregateField()
+     * methods call buildContextualFilter() internally, which automatically adds scope filters
+     * from the executionContext. Adding them here would cause DOUBLE-FILTERING.
+     */
+    async executeCountingQuery(countingConfig, executionContext) {
+        const repository = this.repositoriesRegistry.getRepository(countingConfig.resourceType);
+        if (!repository) {
+            this.logger.warn('Repository not found for counting query — blocking limit check', {
+                resourceType: countingConfig.resourceType,
+            });
+            throw this.errorBuilder.buildError(ErrorType.INTERNAL, executionContext, {
+                context: {
+                    reason: 'FEATURE_COUNTING_REPOSITORY_NOT_FOUND',
+                    resourceType: countingConfig.resourceType,
+                },
+            });
+        }
+        // Pre-check: skip if the resource doesn't have a COUNT operation configured.
+        // Without this guard, repository.count() throws a FATAL-level error that is
+        // caught below but still pollutes logs for a normal configuration scenario.
+        if (!countingConfig.aggregate && !repository.supportsOperation(CoreResourceOperation.COUNT)) {
+            this.logger.warn('COUNT operation not configured — blocking limit check', {
+                resourceType: countingConfig.resourceType,
+            });
+            throw this.errorBuilder.buildError(ErrorType.INTERNAL, executionContext, {
+                context: {
+                    reason: 'FEATURE_COUNTING_OPERATION_NOT_SUPPORTED',
+                    resourceType: countingConfig.resourceType,
+                },
+            });
+        }
+        // Only pass the counting config's static filter (e.g., { status: 'ACTIVE' })
+        const additionalFilter = countingConfig.filter ?? {};
+        try {
+            if (countingConfig.aggregate) {
+                // Field aggregation (SUM, AVG, MAX) — new method on repository
+                return await repository.aggregateField(executionContext, additionalFilter, countingConfig.aggregate.field, countingConfig.aggregate.operation);
+            }
+            else {
+                const { count } = await repository.count(executionContext, additionalFilter);
+                return count;
+            }
+        }
+        catch (error) {
+            this.logger.warn('Counting query failed — blocking limit check', {
+                resourceType: countingConfig.resourceType,
+                error: error?.message,
+            });
+            throw this.errorBuilder.buildError(ErrorType.INTERNAL, executionContext, {
+                context: {
+                    reason: 'FEATURE_COUNTING_QUERY_FAILED',
+                    resourceType: countingConfig.resourceType,
+                    error: error?.message,
+                },
+            });
+        }
+    }
+    // ─────────────────────────────────────────────────────────────
+    // Helpers
+    // ─────────────────────────────────────────────────────────────
+    /**
+     * Infer increment from operation type.
+     * CREATE → 1
+     * CREATE_MANY → array length or 1
+     * otherwise → 0
+     */
+    inferIncrement(operationIdentifier, validatedData) {
+        switch (operationIdentifier) {
+            case CoreResourceOperation.CREATE:
+                return 1;
+            case CoreResourceOperation.CREATE_MANY:
+                return Array.isArray(validatedData) ? validatedData.length : 1;
+            default:
+                return 0;
+        }
+    }
+    /**
+     * Determine if the gate should be bypassed for this operation/context.
+     */
+    shouldBypass(operation, executionContext) {
+        // Internal/system calls bypass feature gating
+        const execType = executionContext.executionType;
+        if (execType === ExecutionContext_ExecutionType.INTERNALLY_INITIATED_REQUEST) {
+            this.logDebug('Bypassing gate — INTERNAL_CALL');
+            return true;
+        }
+        // Public endpoints get defaults-only features (resolved in resolution service).
+        // Gate bypass is safe because PUBLIC_EXECUTION operations should only be on
+        // public-facing resources (login, registration) that don't require feature checks.
+        if (execType === ExecutionContext_ExecutionType.PUBLIC_EXECUTION) {
+            this.logDebug('Bypassing gate — PUBLIC_EXECUTION');
+            return true;
+        }
+        // REPOSITORY_ONLY and INTERNAL_CALL operation variant types bypass
+        const variantType = operation.variantType;
+        if (variantType === ResourceOperationVariantType.REPOSITORY_ONLY ||
+            variantType === ResourceOperationVariantType.INTERNAL_CALL) {
+            this.logDebug('Bypassing gate — operation variant type', { variantType });
+            return true;
+        }
+        // System resources bypass feature gating
+        if (operation.isSystemResource) {
+            this.logDebug('Bypassing gate — system resource', { resourceIdentifier: operation.resourceIdentifier });
+            return true;
+        }
+        return false;
+    }
+};
+FeatureGateBackendService = __decorate([
+    injectable(),
+    __param(0, inject(SAAS_SERVICE_TYPES.Logger)),
+    __param(1, inject(SAAS_SERVICE_TYPES.ErrorBuilderService)),
+    __param(2, inject(SAAS_SERVICE_TYPES.FeatureDefinitionRegistryService)),
+    __param(3, inject(SAAS_SERVICE_TYPES.FeatureResolutionService)),
+    __param(4, inject(SAAS_SERVICE_TYPES.RepositoriesRegistryHandlerService)),
+    __metadata("design:paramtypes", [Function, Function, Function, Function, Function])
+], FeatureGateBackendService);
+export { FeatureGateBackendService };
+//# sourceMappingURL=feature-gate.backend.service.js.map

package/dist/esm/features/services/feature-gate.backend.service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature-gate.backend.service.js","sourceRoot":"","sources":["../../../../src/features/services/feature-gate.backend.service.ts"],"names":[],"mappings":"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"}

package/dist/esm/features/services/feature-resolution.backend.service.d.ts

@@ -0,0 +1,163 @@
+/**
+ * Feature Resolution Backend Service
+ *
+ * Resolves effective features for a given execution context by walking the scope hierarchy
+ * and merging multiple sources: defaults → profile → provider-derived → billing-derived → manual overrides.
+ *
+ * The output is a CONSOLIDATED ResolvedFeatures object that merges ALL applicable scope levels.
+ * The gate service checks this single object — no per-scope lookup at gate time.
+ *
+ * Cache: Redis with configurable TTL. Key format: `features:{scopeType}:{entityId}`.
+ */
+import type { Container } from 'inversify';
+import { ResourcePrimaryScope, type ResolvedFeatures, type ResolvedFeaturesWithUsage } from '@wildo-ai/saas-models';
+import type { LoggerService } from '../../monitoring/logger/services/logger.service.js';
+import type { RedisService } from '../../databases/services/redis.service.js';
+import type { FeatureDefinitionRegistryBackendService } from './feature-definition-registry.backend.service.js';
+import type { CapabilityBindingsBackendService } from '../../external-providers/services/feature-bindings.backend.service.js';
+import type { ExecutionContextCreatorBackendService } from '../../runtime/services/execution-context-creator.backend.service.js';
+import type { ResourcesRegistryBackendService } from '../../resources/services/resources-registry.backend.service.js';
+import type { ExecutionContext } from '../../runtime/models/execution-context.backend.schemas.js';
+import type { AppConfigurationService } from '../../config/services/app-configuration.backend.service.js';
+export declare class FeatureResolutionBackendService {
+    private readonly logger;
+    private readonly redisService;
+    private readonly featureRegistry;
+    private readonly capabilityBindings;
+    private readonly appConfigService;
+    private readonly container;
+    private readonly executionContextCreator;
+    private readonly resourcesRegistry;
+    private logDebug;
+    private _servicesRegistry;
+    constructor(logger: LoggerService, redisService: RedisService, featureRegistry: FeatureDefinitionRegistryBackendService, capabilityBindings: CapabilityBindingsBackendService, appConfigService: AppConfigurationService, container: Container, executionContextCreator: ExecutionContextCreatorBackendService, resourcesRegistry: ResourcesRegistryBackendService);
+    private get servicesRegistry();
+    /**
+     * Resolve effective features for the current execution context.
+     * Walks the scope hierarchy based on ExecutionType and returns a CONSOLIDATED result.
+     */
+    resolve(executionContext: ExecutionContext<any>): Promise<ResolvedFeatures>;
+    /**
+     * Resolve effective features for a specific scope entity (standalone, not context-aware).
+     * Does NOT walk the scope hierarchy — resolves a single scope starting from defaults.
+     */
+    resolveForScope(scopeType: ResourcePrimaryScope, scopeEntityId: string): Promise<ResolvedFeatures>;
+    /**
+     * Check if a boolean feature is enabled for the given execution context.
+     */
+    isFeatureEnabled(featureId: string, executionContext: ExecutionContext<any>): Promise<boolean>;
+    /**
+     * Get the limit value for a LIMIT feature.
+     * Returns FEATURES_UNLIMITED if the feature is not found (permissive default).
+     */
+    getLimit(featureId: string, executionContext: ExecutionContext<any>): Promise<number>;
+    /**
+     * Get resolved features WITH current usage placeholder.
+     * Actual usage population is done in FeaturesControllerBackendService, which injects
+     * FeatureGateBackendService directly (no circular dependency at the controller level).
+     */
+    resolveWithUsage(executionContext: ExecutionContext<any>): Promise<ResolvedFeaturesWithUsage>;
+    /**
+     * Invalidate cached features for a scope entity.
+     * Call on: feature override changes, subscription changes, provider binding changes.
+     */
+    invalidateCache(scopeType: ResourcePrimaryScope, entityId: string): Promise<void>;
+    /**
+     * Invalidate cached features for all scope levels of an execution context.
+     * Convenience method for when a change affects the entire resolution chain.
+     */
+    invalidateCacheForContext(executionContext: ExecutionContext<any>): Promise<void>;
+    /**
+     * Resolve features for a single scope level, starting from a base (parent scope's features).
+     * Checks cache first, then resolves from sources if cache miss.
+     */
+    private resolveForScopeInternal;
+    /**
+     * Step A: Build defaults from feature definitions.
+     * Boolean features with defaultValue=true → enabled.
+     * Limit features → default numeric value.
+     */
+    private buildDefaults;
+    /**
+     * Step B: Apply config profile.
+     * When billing is DISABLED: applies the defaultProfile from FeatureConfiguration.
+     * When billing is ENABLED: profiles are NOT used (features come from subscriptions).
+     */
+    private applyProfile;
+    /**
+     * Step C: Layer provider-derived features (APPLICATION scope only).
+     * Checks CapabilityBindingsBackendService for all EngineCapabilities with active providers.
+     * Each bound EngineCapability becomes an enabled boolean feature.
+     */
+    private applyProviderDerivedFeatures;
+    /**
+     * Steps D + E: Read the scope features document and apply billing-derived features
+     * AND manual overrides in a single DB read.
+     *
+     * The scope features document (e.g., ORGANIZATION_FEATURES) has:
+     * - `features` / `limits`: written by BillingFeatureSyncBackendService on subscription changes
+     * - `manualOverrides`: written by admin actions (ENABLE_FEATURE, DISABLE_FEATURE, etc.)
+     *
+     * Resolution order:
+     * 1. Merge billing-derived `features`/`limits` onto base (union/most-permissive)
+     * 2. Apply manual overrides on top (addedFeatures, removedFeatures, limitOverrides)
+     *    → Manual overrides always win.
+     */
+    private applyBillingAndManualOverrides;
+    /**
+     * Read the scope features document for a given scope entity.
+     * Returns null if no document exists (entity has no features record yet).
+     *
+     * Uses READ operation (not LIST) because all scope features resources
+     * have READ configured, while USER_FEATURES does not expose LIST. The repository's `read` method accepts a filter
+     * object (uses MongoDB `findOne` internally), which is exactly what we need.
+     */
+    private getScopeFeatureDocument;
+    /**
+     * Map scope type to the corresponding features resource type.
+     */
+    private getScopeFeaturesResourceType;
+    /**
+     * Map scope type to the foreign key field name used in the features resource.
+     */
+    private getScopeForeignKeyField;
+    /**
+     * Apply manual overrides from a ScopeFeaturesWithOverrides document.
+     * Manual overrides always win: addedFeatures are unioned, removedFeatures are excluded,
+     * limitOverrides directly replace computed values.
+     */
+    private applyOverridesFromDocument;
+    private mergeAndPruneEffectiveFeatures;
+    /**
+     * Keep every resolution source honest about the shared `applicableScopes`
+     * contract so defaults, profiles, and persisted scope docs cannot leak
+     * app-only or org-only feature ids into the wrong resolution layer.
+     */
+    private filterScopeFeaturesForScope;
+    private isDefinitionApplicableToScope;
+    /**
+     * Step F: Prune features whose dependencies are not met.
+     * A feature is disabled if any of its dependencies is not in the enabled set.
+     *
+     * Uses iterative pruning (not single-pass) to handle transitive dependencies:
+     * If A depends on B and B depends on C, removing C must also remove B and then A.
+     * Loops until no more features are pruned (stable set).
+     */
+    private pruneDependencies;
+    /**
+     * Build the scope chain to resolve based on execution type.
+     * Returns scope levels from broadest (app) to most specific (user).
+     */
+    private buildScopeChain;
+    /**
+     * Build a cache key for a scope entity.
+     * Format: `features:{scopeType}:{entityId}`
+     */
+    private buildCacheKey;
+    /**
+     * Build a ResolvedFeatures with ALL features enabled and all limits set to UNLIMITED.
+     * Used for internal/system calls that bypass feature gating.
+     */
+    private buildAllFeaturesEnabled;
+}
+//# sourceMappingURL=feature-resolution.backend.service.d.ts.map

package/dist/esm/features/services/feature-resolution.backend.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature-resolution.backend.service.d.ts","sourceRoot":"","sources":["../../../../src/features/services/feature-resolution.backend.service.ts"],"names":[],"mappings":"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"}