@wildo-ai/saas-backend-lib 1.0.1

package/src/resources/services/resources-registry.backend.service.ts

@@ -0,0 +1,1126 @@
+import { injectable, inject } from 'inversify';
+import {
+    ResourcesRegistry,
+    ResourceRelationship,
+    NotificationBadgeDefinition,
+    UserNotificationDefinition,
+    ResourceConfiguration_Operation,
+    ResourceConfiguration_OperationPath,
+    AnyResourceConfiguration,
+    ResourceConfiguration_InitializationFactoryMap,
+    coreShared_ResourcesConfigurations_FactoryMap,
+    coreResourceShared_FieldIdentifier,
+    coreResourceShared_FieldIdentifierPriority,
+    coreSharedResourceRelationship,
+    ResourceType,
+    ResourcesConfigOperationsUrlsBuilderUtils,
+    ResourcesConfigOperationsDtosBuilderUtils,
+    ResourcesConfig_OperationPathUtils,
+    ResourceOperationVariantType,
+    ErrorType,
+    ErrorCustomMessageReference,
+    ResourceConfiguration_Operation_UrlInitiatorInfo,
+    ResourceConfiguration_Operation_UrlParameterInfo,
+    PersistenceAdapterType,
+    DEFAULT_PERSISTENCE_ADAPTER,
+    CoreResourceOperation,
+    ResourceParentResourceRequirement,
+    reconcileGeneratedRelationshipBulkOperations,
+    Resources_SharedUtils,
+} from '@wildo-ai/saas-models';
+import { BackendResourcesSources } from '~wildo-backend-lib/resources/models/resources.backend.schemas';
+import { backendResourcesConfigurationsFactoryMap } from '~wildo-backend-lib/resources/models/resources-operations.backend.definitions';
+import { backendResourcesRelationships } from '~wildo-backend-lib/resources/models/resources-relationships.backend.definitions';
+import { BackendResourceFieldIdentifier } from '~wildo-backend-lib/resources/models/resources-types.backend.schemas';
+import { SAAS_SERVICE_TYPES } from '~wildo-backend-lib/inject/models/service-types';
+import type { LoggerService } from '~wildo-backend-lib/monitoring/logger/services/logger.service';
+import type { AppConfigurationService } from '~wildo-backend-lib/config/services/app-configuration.backend.service';
+import { ErrorBuilderBackendService } from '~wildo-backend-lib/errors/services/error-builder.backend.service';
+import type { z } from 'zod';
+
+@injectable()
+export class ResourcesRegistryBackendService {
+    protected logDebug: (message: string, context?: Record<string, unknown>) => void;
+    protected registry: ResourcesRegistry | null = null;
+
+    protected isInitialized = false;
+
+    constructor(
+        @inject(SAAS_SERVICE_TYPES.Logger) protected readonly logger: LoggerService,
+        @inject(SAAS_SERVICE_TYPES.AppConfigService) protected readonly configService: AppConfigurationService,
+        @inject(SAAS_SERVICE_TYPES.ErrorBuilderService) protected readonly errorBuilder: ErrorBuilderBackendService
+    ) {
+        this.logDebug = this.logger.debugByType('ResourcesRegistryBackendService');
+        this.logger.setDebugTypeLogging('ResourcesRegistryBackendService', false);
+
+        this.logDebug('Resources registry service created (not yet initialized)');
+    }
+
+    /**
+     * W5.1: Returns organizationTypes config when app config is initialized.
+     * Used by organization create validation to ensure Organization.type is a valid key.
+     * Returns undefined when config is not initialized (e.g. platform mode).
+     */
+    public getOrganizationTypesConfig(): Record<string, unknown> | undefined {
+        if (!this.configService.isInitialized()) return undefined;
+        const config = this.configService.config;
+        return (config as { organizationTypes?: Record<string, unknown> })?.organizationTypes;
+    }
+
+    /**
+     * W5.9: Returns userTypes config when app config is initialized.
+     * Used by user type revocation to check requiresOrgMembership constraints.
+     */
+    public getUserTypesConfig(): Record<string, unknown> | undefined {
+        if (!this.configService.isInitialized()) return undefined;
+        const config = this.configService.config;
+        return (config as { userTypes?: Record<string, unknown> })?.userTypes;
+    }
+
+    // ================================
+    // Initialization Method
+    // ================================
+
+    public async initialize<
+        CustomShared_ResourceType extends ResourceType | undefined = undefined,
+        CustomBackend_ResourceType extends ResourceType | undefined = undefined
+    >(
+        customShared_ResourcesConfigurationsFactoryMap : ResourceConfiguration_InitializationFactoryMap<CustomShared_ResourceType>,
+        customShared_ResourceFieldIdentifier: { [ key: string ]: string } | undefined,
+        customShared_ResourcesRelationships: ResourceRelationship[],
+        customBackend_ResourcesConfigurationsFactoryMap : ResourceConfiguration_InitializationFactoryMap<CustomBackend_ResourceType>,
+        customBackend_ResourceFieldIdentifier: { [ key: string ]: string } | undefined,
+        customBackend_ResourcesRelationships: ResourceRelationship[],
+        customNotificationBadgeDefinitions?: NotificationBadgeDefinition[],
+        customAdditionalUserNotificationDefinitions?: UserNotificationDefinition[],
+        excludedResourceTypes?: ReadonlySet<string>,
+    ): Promise<void> {
+        if (this.isInitialized) {
+            this.logDebug('Service already initialized, skipping');
+            return;
+        }
+
+        const coreBackend_ResourceConfigurationFactoryMaps = backendResourcesConfigurationsFactoryMap;
+        const coreBackend_ResourceRelationship = backendResourcesRelationships;
+        const coreBackend_FieldIdentifier = BackendResourceFieldIdentifier;
+
+        const allResourceFieldIdentifiers : { [ key: string ]: string } = {
+            ...customShared_ResourceFieldIdentifier,
+            ...customBackend_ResourceFieldIdentifier,
+            ...coreBackend_FieldIdentifier,
+            ...coreResourceShared_FieldIdentifier,
+        };
+
+        let allResourceRelationships : ResourceRelationship[] = Resources_SharedUtils.ensureCompiledRelationships([
+            ...(customShared_ResourcesRelationships || []),
+            ...(customBackend_ResourcesRelationships || []),
+            ...coreSharedResourceRelationship,
+            ...coreBackend_ResourceRelationship,
+        ]);
+
+        // Apply factory functions for custom shared resources configurations
+        const customShared_ResourcesConfigurations: { [key: string]: AnyResourceConfiguration } = {};
+        if (customShared_ResourcesConfigurationsFactoryMap && Object.keys(customShared_ResourcesConfigurationsFactoryMap).length > 0) {
+            Object.entries(customShared_ResourcesConfigurationsFactoryMap).forEach(([resourceType, factory]) => {
+                if (factory && typeof factory === 'function') {
+                    this.logDebug(`🏭 Calling factory for custom resource: ${resourceType}`);
+                    customShared_ResourcesConfigurations[resourceType] = factory(allResourceRelationships);
+                    this.logDebug(`✅ Factory completed for ${resourceType}`);
+                }
+            });
+        }
+
+        // Apply factory functions for custom backend resources configurations
+        const customBackend_ResourcesConfigurations: { [key: string]: AnyResourceConfiguration } = {};
+        if (customBackend_ResourcesConfigurationsFactoryMap && Object.keys(customBackend_ResourcesConfigurationsFactoryMap).length > 0) {
+            Object.entries(customBackend_ResourcesConfigurationsFactoryMap).forEach(([resourceType, factory]) => {
+                if (factory && typeof factory === 'function') {
+                    customBackend_ResourcesConfigurations[resourceType] = factory(allResourceRelationships);
+                }
+            });
+        }
+
+        // Apply factory functions for core shared resources configurations
+        const coreShared_ResourcesConfigurations: { [key: string]: AnyResourceConfiguration } = {};
+        if (coreShared_ResourcesConfigurations_FactoryMap && Object.keys(coreShared_ResourcesConfigurations_FactoryMap).length > 0) {
+            Object.entries(coreShared_ResourcesConfigurations_FactoryMap).forEach(([resourceType, factory]) => {
+                if (factory && typeof factory === 'function') {
+                    coreShared_ResourcesConfigurations[resourceType] = factory(allResourceRelationships);
+                }
+            });
+        }
+
+        // Apply factory functions for core backend resources configurations
+        const coreBackend_ResourcesConfigurations: { [key: string]: AnyResourceConfiguration } = {};
+        if (coreBackend_ResourceConfigurationFactoryMaps && Object.keys(coreBackend_ResourceConfigurationFactoryMaps).length > 0) {
+            Object.entries(coreBackend_ResourceConfigurationFactoryMaps).forEach(([resourceType, factory]) => {
+                if (factory && typeof factory === 'function') {
+                    coreBackend_ResourcesConfigurations[resourceType] = factory(allResourceRelationships);
+                }
+            });
+        }
+
+        // Merge all resource configurations
+        let allResourceConfigurations : { [key: string]: AnyResourceConfiguration } = {
+            ...coreShared_ResourcesConfigurations,
+            ...coreBackend_ResourcesConfigurations,
+            ...customShared_ResourcesConfigurations,
+            ...customBackend_ResourcesConfigurations,
+        };
+
+        // ── Resource Exclusion ─────────────────────────────────────────
+        // Generic mechanism: remove excluded resource types from all 3 layers
+        // (configurations, relationships, field identifiers).
+        // Used for billing-conditional resources when billing is disabled.
+        if (excludedResourceTypes && excludedResourceTypes.size > 0) {
+            this.logDebug(`Excluding ${excludedResourceTypes.size} resource types from registry`, {
+                excludedTypes: [...excludedResourceTypes],
+            });
+
+            // Layer 1: Remove excluded resource configurations
+            allResourceConfigurations = Object.fromEntries(
+                Object.entries(allResourceConfigurations).filter(
+                    ([resourceType]) => !excludedResourceTypes.has(resourceType)
+                )
+            );
+
+            // Layer 2: Remove relationships that reference excluded types
+            allResourceRelationships = allResourceRelationships.filter(
+                (rel) => !excludedResourceTypes.has(rel.resourceType1) && !excludedResourceTypes.has(rel.resourceType2)
+            );
+
+            // Layer 3: Remove excluded field identifiers
+            for (const resourceType of excludedResourceTypes) {
+                delete allResourceFieldIdentifiers[resourceType];
+            }
+
+            this.logDebug('Resource exclusion applied', {
+                remainingConfigurations: Object.keys(allResourceConfigurations).length,
+                remainingRelationships: allResourceRelationships.length,
+            });
+        }
+
+        reconcileGeneratedRelationshipBulkOperations(
+            allResourceConfigurations,
+            allResourceRelationships,
+            allResourceFieldIdentifiers
+        );
+
+        ResourcesConfigOperationsDtosBuilderUtils.rebuildResourceConfigurationsOperationDtos(
+            allResourceConfigurations
+        );
+
+        // Build reverse map: fieldIdentifier -> resourceType (e.g., userId -> USERS)
+        // Track shared field identifiers (multiple resource types using the same field id,
+        // e.g. USER_SELF and USERS both use "userId") so the FK collision check allows them.
+        const fieldIdentifierToResourceType: Record<string, ResourceType> = {};
+        const sharedFieldIdentifiers = new Map<string, Set<string>>();
+        for (const [resourceType, fieldIdentifier] of Object.entries(allResourceFieldIdentifiers)) {
+            const existing = fieldIdentifierToResourceType[fieldIdentifier];
+            if (existing && existing !== resourceType) {
+                if (!sharedFieldIdentifiers.has(fieldIdentifier)) {
+                    sharedFieldIdentifiers.set(fieldIdentifier, new Set([existing]));
+                }
+                sharedFieldIdentifiers.get(fieldIdentifier)!.add(resourceType);
+            }
+            fieldIdentifierToResourceType[fieldIdentifier] = resourceType as ResourceType;
+        }
+
+        // Enrich the map with explicit foreignKeyField entries from relationships.
+        // This enables FK resolution for non-default fields (e.g., assignedToUserId → USERS).
+        // Convention: resourceType1 = PARENT, foreignKeyField is on the CHILD pointing to PARENT.
+        // Multiple resources may declare the same foreignKeyField (e.g., createdByUserId) as
+        // long as they all participate in relationships with the same counterpart resource type.
+        const fkFieldCounterpart: Record<string, string> = {};
+        for (const rel of allResourceRelationships) {
+            if (rel.foreignKeyField) {
+                const existingType = fieldIdentifierToResourceType[rel.foreignKeyField];
+                if (existingType && existingType !== rel.resourceType1) {
+                    const sharedTypes = sharedFieldIdentifiers.get(rel.foreignKeyField);
+                    if (sharedTypes && sharedTypes.has(rel.resourceType1)) {
+                        continue;
+                    }
+                    const existingCounterpart = fkFieldCounterpart[rel.foreignKeyField];
+                    if (existingCounterpart && existingCounterpart === rel.resourceType2) {
+                        continue;
+                    }
+                    const collisionMessage =
+                        `[ResourcesRegistry] FK field "${rel.foreignKeyField}" maps to both ` +
+                        `"${existingType}" and "${rel.resourceType1}". ` +
+                        `Fix the relationship declarations or use distinct foreignKeyField names.`;
+                    this.logger.error(collisionMessage, { existingType, newType: rel.resourceType1, foreignKeyField: rel.foreignKeyField });
+                    throw this.errorBuilder.buildError(
+                        ErrorType.CONFIGURATION,
+                        undefined,
+                        {
+                            customMessageReference: ErrorCustomMessageReference.REGISTRY_FK_MAP_COLLISION,
+                            context: { existingType, newType: rel.resourceType1, foreignKeyField: rel.foreignKeyField }
+                        }
+                    );
+                }
+                fieldIdentifierToResourceType[rel.foreignKeyField] = rel.resourceType1 as ResourceType;
+                fkFieldCounterpart[rel.foreignKeyField] = rel.resourceType2;
+            }
+        }
+
+        // Apply canonical priority for shared field identifiers.
+        // When multiple resource types share the same field identifier (e.g., userId
+        // is shared by USERS and USER_SELF), the canonical type is set here — not by
+        // relationship iteration order.
+        for (const [fieldId, canonicalType] of Object.entries(coreResourceShared_FieldIdentifierPriority)) {
+            if (sharedFieldIdentifiers.has(fieldId)) {
+                fieldIdentifierToResourceType[fieldId] = canonicalType as ResourceType;
+            }
+        }
+
+        // Create the final registry
+        this.registry = {
+            notificationBadgeDefinitions: [],
+            additionalUserNotificationDefinitions: [],
+            resourceRelationships: allResourceRelationships,
+            resourceConfigurations: allResourceConfigurations,
+            allResourceFieldIdentifiers,
+            fieldIdentifierToResourceType,
+        };
+
+        // Validate all relationships can resolve FK fields
+        this.logDebug('Validating relationship FK field resolution');
+        this.validateRelationshipForeignKeyFields(allResourceRelationships, allResourceFieldIdentifiers);
+
+        // Validate relationship graph for cycles
+        this.logDebug('Validating relationship graph for cycles');
+        this.validateRelationshipGraph(allResourceRelationships);
+
+        // Validate persistence adapter configuration for all resources
+        this.logDebug('Validating persistence adapter configuration');
+        this.validatePersistenceAdapterConfiguration(allResourceConfigurations);
+
+        this.logDebug('Generating URLs for API_CALL operations');
+        this.generateUrlsForAllResourceConfigurations(allResourceConfigurations, this.registry, allResourceFieldIdentifiers);
+
+        this.logDebug('Enhancing DTOs for all operations');
+        this.enhanceDtosForAllResourceConfigurations(allResourceConfigurations, this.registry, allResourceFieldIdentifiers);
+
+        this.isInitialized = true;
+        this.logDebug('Resources registry initialized successfully', { totalConfigurations: Object.keys(allResourceConfigurations).length, totalRelationships: allResourceRelationships.length });
+
+        //Debug display generated URLs after initialization is complete
+        this.logDebug('Displaying generated URLs for debugging');
+        this.debugDisplayGeneratedUrls();
+
+        // Debug display generated DTOs after initialization is complete
+        // this.logDebug('Displaying generated DTOs for debugging');
+        // this.debugDisplayGeneratedDtos();
+
+    }
+
+
+
+    // ================================
+    // Access Methods
+    // ================================
+
+    public getResourcesRegistry(): ResourcesRegistry {
+        this.ensureInitialized();
+        return this.registry!;
+    }
+
+
+    public getResourceTypes(): ResourceType[] {
+        this.ensureInitialized();
+        return Object.keys(this.registry!.resourceConfigurations) as ResourceType[];
+    }
+
+    /**
+     * Get the map of resource types to their standard field identifiers.
+     * Used for FK field resolution without string manipulation.
+     *
+     * @example USERS -> userId, ORGANIZATIONS -> organizationId, USER_SELF -> userId
+     */
+    public getAllResourceFieldIdentifiers(): Record<ResourceType, string> {
+        this.ensureInitialized();
+        return this.registry!.allResourceFieldIdentifiers;
+    }
+
+    /**
+     * Resolve the foreign key field name for a relationship.
+     *
+     * Priority:
+     * 1. Explicit foreignKeyField from relationship (for disambiguation)
+     * 2. Lookup in allResourceFieldIdentifiers map (authoritative source)
+     * 3. Throws error if not found (no string manipulation fallback)
+     *
+     * @param relationship - The resource relationship
+     * @returns The FK field name
+     * @throws Error if resource type not found in allResourceFieldIdentifiers
+     */
+    public resolveForeignKeyField(relationship: { resourceType1: ResourceType; foreignKeyField?: string }): string {
+        this.ensureInitialized();
+        const resolved = Resources_SharedUtils.tryResolveRelationshipForeignKeyIdentity(
+            {
+                resourceType1: relationship.resourceType1,
+                resourceType2: relationship.resourceType1,
+                foreignKeyField: relationship.foreignKeyField,
+            },
+            this.registry!.allResourceFieldIdentifiers
+        );
+
+        if (!resolved) {
+            throw this.errorBuilder.buildError(
+                ErrorType.CONFIGURATION,
+                undefined,
+                {
+                    customMessageReference: ErrorCustomMessageReference.RESOURCES_REGISTRY_FIELD_IDENTIFIER_NOT_FOUND,
+                    context: {
+                        resourceType: relationship.resourceType1,
+                        hint: 'Resource type must be registered with a resourceFieldIdentifier'
+                    }
+                }
+            );
+        }
+
+        return resolved.fieldIdentifier;
+    }
+
+    /**
+     * Get the reverse map of field identifiers to resource types.
+     * Used for quick lookup of resource type from a FK field name.
+     *
+     * @example userId -> USERS, organizationId -> ORGANIZATIONS
+     */
+    public getFieldIdentifierToResourceType(): Record<string, ResourceType> {
+        this.ensureInitialized();
+        return this.registry!.fieldIdentifierToResourceType;
+    }
+
+    /**
+     * Resolve the resource type from a FK field name.
+     *
+     * @param fkField - The foreign key field name (e.g., 'userId', 'organizationId')
+     * @returns The resource type or undefined if not found
+     */
+    public resolveResourceTypeFromForeignKeyField(fkField: string): ResourceType | undefined {
+        this.ensureInitialized();
+        return this.registry!.fieldIdentifierToResourceType[fkField];
+    }
+
+    public getOperationPathDefault(resourceType: ResourceType, operationIdentifier: string): ResourceConfiguration_OperationPath<any, any> {
+        this.ensureInitialized();
+        const registry = this.getResourcesRegistry();
+        const resourceConfig = registry.resourceConfigurations[resourceType];
+        const operation = resourceConfig.operations.find((operation) => operation.operationIdentifier === operationIdentifier && operation.isOperationDefault);
+        if (!operation) {
+            throw this.errorBuilder.buildError(
+                ErrorType.INTERNAL,
+                undefined,
+                {
+                    customMessageReference: ErrorCustomMessageReference.RESOURCES_REGISTRY_OPERATION_PATH_NOT_FOUND,
+                    context: { resourceType, operationIdentifier, }
+                }
+            );
+        }
+        return ResourcesConfig_OperationPathUtils.extractOperationPath(operation);
+    }
+
+    /**
+     * Get operation path for a specific variant.
+     * @param resourceType - The resource type
+     * @param operationIdentifier - The operation identifier (e.g., CoreResourceOperation.READ)
+     * @param variantKey - The variant key (e.g., 'summary', 'context')
+     */
+    public getOperationPath(resourceType: ResourceType, operationIdentifier: string, variantKey: string): ResourceConfiguration_OperationPath<any, any> {
+        this.ensureInitialized();
+        const registry = this.getResourcesRegistry();
+        const resourceConfig = registry.resourceConfigurations[resourceType];
+
+        const operation = resourceConfig.operations.find((op) =>
+            op.operationIdentifier === operationIdentifier &&
+            op.variantKey === variantKey &&
+            !op.isOperationDefault
+        );
+
+        if (!operation) {
+            throw this.errorBuilder.buildError(
+                ErrorType.INTERNAL,
+                undefined,
+                {
+                    customMessageReference: ErrorCustomMessageReference.RESOURCES_REGISTRY_OPERATION_PATH_NOT_FOUND,
+                    context: { resourceType, operationIdentifier, variantKey }
+                }
+            );
+        }
+        return ResourcesConfig_OperationPathUtils.extractOperationPath(operation);
+    }
+
+    public getOperationFromPath( operationPath: ResourceConfiguration_OperationPath<any, any> ): ResourceConfiguration_Operation<any, any, any> {
+
+        this.ensureInitialized();
+        const registry = this.getResourcesRegistry();
+
+        const resourceConfig = registry.resourceConfigurations[operationPath.resourceIdentifier];
+
+        const matchedOperation = resourceConfig.operations.find((operation) => {
+            if (operation.operationIdentifier !== operationPath.operationIdentifier) return false;
+            if (operation.variantType !== operationPath.variantType) return false;
+
+            // Match default/variant key
+            if (operationPath.isOperationDefault) {
+                if (!operation.isOperationDefault) return false;
+            } else {
+                const expectedVariantKey = operationPath.variantKey;
+                const actualVariantKey = operation.variantKey;
+                if ((actualVariantKey ?? undefined) !== (expectedVariantKey ?? undefined)) return false;
+            }
+
+            // For API_CALL operations, also match bulk flag
+            if (operation.variantType === ResourceOperationVariantType.API_CALL) {
+                const opIsBulk = (operation as any).isBulkOperation === true;
+                const pathIsBulk = operationPath.isBulkOperation === true;
+                return opIsBulk === pathIsBulk;
+            }
+
+            return true;
+        });
+
+        if (!matchedOperation) {
+            // As per requirement, assume it exists; if not, throw unified WildoError_Backend
+            const key = ResourcesConfig_OperationPathUtils.createOperationPathKey(operationPath);
+            throw this.errorBuilder.buildError(
+                ErrorType.VALIDATION,
+                undefined,
+                {
+                    customMessageReference: ErrorCustomMessageReference.RESOURCES_REGISTRY_REGISTRATION_FAILED,
+                    context: {
+                        message: 'Operation not found in resources registry',
+                        operationPathKey: key,
+                        resourceIdentifier: operationPath.resourceIdentifier,
+                        operationIdentifier: operationPath.operationIdentifier,
+                        variantType: operationPath.variantType,
+                        isOperationDefault: operationPath.isOperationDefault,
+                        variantKey: operationPath.variantKey,
+                        isBulkOperation: operationPath.isBulkOperation
+                    }
+                }
+            );
+        }
+
+        return matchedOperation as ResourceConfiguration_Operation<any, any, any>;
+    }
+
+    public getRequestDtoFromPath(operationPath: ResourceConfiguration_OperationPath<any, any>) : z.ZodTypeAny {
+        this.ensureInitialized();
+        const operation = this.getOperationFromPath(operationPath);
+        return operation.requestDto;
+    }
+
+    public getResponseDtoFromPath(operationPath: ResourceConfiguration_OperationPath<any, any>) : z.ZodTypeAny {
+        this.ensureInitialized();
+        const operation = this.getOperationFromPath(operationPath);
+        return operation.responseDto;
+    }
+
+    public getMainSchemaFromPath(operationPath: ResourceConfiguration_OperationPath<any, any>) : z.ZodTypeAny {
+        this.ensureInitialized();
+        const operation = this.getOperationFromPath(operationPath);
+        return operation.mainSchema;
+    }
+
+    public getDatabaseSchemaFromPath(operationPath: ResourceConfiguration_OperationPath<any, any>) : z.ZodTypeAny {
+        this.ensureInitialized();
+        const operation = this.getOperationFromPath(operationPath);
+        // NOTE: databaseSchema was removed - mainSchema now contains all fields including backend-only
+        return operation.mainSchema;
+    }
+
+    public getResourceConfiguration(resourceType: ResourceType): AnyResourceConfiguration {
+        this.ensureInitialized();
+        const config = this.registry!.resourceConfigurations[resourceType];
+        if (!config) {
+            throw this.errorBuilder.buildError(ErrorType.INTERNAL, undefined, {
+                customMessageReference: ErrorCustomMessageReference.RESOURCES_REGISTRY_INITIALIZATION_FAILED,
+            });
+        }
+        return config;
+    }
+
+    /**
+     * Safe variant that returns undefined for unregistered resource types
+     * instead of throwing. Use when the caller handles missing configs gracefully.
+     */
+    public tryGetResourceConfiguration(resourceType: ResourceType): AnyResourceConfiguration | undefined {
+        this.ensureInitialized();
+        return this.registry!.resourceConfigurations[resourceType];
+    }
+
+    // ================================
+    // Initialization Utils
+    // ================================
+
+    protected ensureInitialized(): void {
+        if (!this.isInitialized || !this.registry) {
+            throw this.errorBuilder.buildError( ErrorType.INTERNAL, undefined, { customMessageReference: ErrorCustomMessageReference.RESOURCES_REGISTRY_INITIALIZATION_FAILED } );
+        }
+    }
+
+    /**
+     * Validate that all relationships can resolve their FK fields at startup.
+     * This catches configuration errors early (e.g., missing resourceFieldIdentifier).
+     */
+    protected validateRelationshipForeignKeyFields(
+        allResourceRelationships: ResourceRelationship[],
+        allResourceFieldIdentifiers: Record<string, string>
+    ): void {
+        const errors: string[] = [];
+
+        for (const relationship of allResourceRelationships) {
+            // Skip disabled relationships
+            if (relationship.isDisabled) continue;
+
+            const resolved = Resources_SharedUtils.tryResolveRelationshipForeignKeyIdentity(
+                relationship,
+                allResourceFieldIdentifiers
+            );
+            if (!resolved) {
+                errors.push(
+                    `Relationship ${relationship.resourceType1} → ${relationship.resourceType2}: ` +
+                    `No resourceFieldIdentifier registered for ${relationship.resourceType1}. ` +
+                    `Either add it to the resourceFieldIdentifiers map or specify foreignKeyField explicitly.`
+                );
+            }
+        }
+
+        if (errors.length > 0) {
+            this.logger.error('FK field validation failed for relationships:', { errors });
+            throw this.errorBuilder.buildError(
+                ErrorType.CONFIGURATION,
+                undefined,
+                {
+                    customMessageReference: ErrorCustomMessageReference.RESOURCES_REGISTRY_RELATIONSHIP_VALIDATION_FAILED,
+                    context: { errors }
+                }
+            );
+        }
+
+        this.logDebug(`Validated FK field resolution for ${allResourceRelationships.length} relationships`);
+    }
+
+    /**
+     * Validate the relationship graph for cycles at startup (fail-fast).
+     *
+     * Builds a directed graph from all relationships (resourceType1 → resourceType2)
+     * and runs DFS-based cycle detection. Self-loops (resourceType1 === resourceType2)
+     * and transitive cycles (A → B → C → A) are both detected.
+     *
+     * When a cycle is found, every edge in the cycle must have `allowCycle: true`.
+     * If any edge lacks the flag, a configuration error is thrown listing the cycle path.
+     *
+     * Performance: O(V + E) where V = distinct resource types, E = relationship count.
+     * Typical: V ≈ 50, E ≈ 80. Runs once at startup — negligible cost.
+     */
+    protected validateRelationshipGraph(allResourceRelationships: ResourceRelationship[]): void {
+        // Build adjacency list with edge metadata
+        const adjacency = new Map<string, Array<{ target: string; allowCycle: boolean; rel: ResourceRelationship }>>();
+        const allNodes = new Set<string>();
+
+        for (const rel of allResourceRelationships) {
+            if (rel.isDisabled) continue;
+
+            allNodes.add(rel.resourceType1);
+            allNodes.add(rel.resourceType2);
+
+            if (!adjacency.has(rel.resourceType1)) {
+                adjacency.set(rel.resourceType1, []);
+            }
+            adjacency.get(rel.resourceType1)!.push({
+                target: rel.resourceType2,
+                allowCycle: rel.allowCycle || false,
+                rel,
+            });
+        }
+
+        // DFS cycle detection with path tracking
+        // States: WHITE (unvisited), GRAY (in current DFS path), BLACK (fully processed)
+        const WHITE = 0, GRAY = 1, BLACK = 2;
+        const color = new Map<string, number>();
+        for (const node of allNodes) color.set(node, WHITE);
+
+        // Track the current DFS path for cycle reconstruction
+        const path: string[] = [];
+        const errors: string[] = [];
+
+        const dfs = (node: string): void => {
+            color.set(node, GRAY);
+            path.push(node);
+
+            const edges = adjacency.get(node) || [];
+            for (const edge of edges) {
+                const targetColor = color.get(edge.target);
+
+                if (targetColor === GRAY) {
+                    // Cycle found — extract the cycle from path
+                    const cycleStart = path.indexOf(edge.target);
+                    const cyclePath = [...path.slice(cycleStart), edge.target];
+
+                    // Check if ALL edges in the cycle have allowCycle: true
+                    const cycleEdges: Array<{ from: string; to: string; allowCycle: boolean }> = [];
+                    for (let i = 0; i < cyclePath.length - 1; i++) {
+                        const from = cyclePath[i];
+                        const to = cyclePath[i + 1];
+                        const edgeData = adjacency.get(from)?.find(e => e.target === to);
+                        cycleEdges.push({
+                            from,
+                            to,
+                            allowCycle: edgeData?.allowCycle || false,
+                        });
+                    }
+
+                    const allAllowed = cycleEdges.every(e => e.allowCycle);
+                    if (!allAllowed) {
+                        const missingFlags = cycleEdges
+                            .filter(e => !e.allowCycle)
+                            .map(e => `${e.from} → ${e.to}`);
+                        errors.push(
+                            `Cycle detected: ${cyclePath.join(' → ')}. ` +
+                            `Edges missing allowCycle: [${missingFlags.join(', ')}]. ` +
+                            `Set allowCycle: true on all edges in the cycle to allow it.`
+                        );
+                    } else {
+                        this.logDebug(`Allowed cycle detected: ${cyclePath.join(' → ')} (all edges have allowCycle: true)`);
+                    }
+                } else if (targetColor === WHITE) {
+                    dfs(edge.target);
+                }
+                // BLACK: already fully processed, skip
+            }
+
+            path.pop();
+            color.set(node, BLACK);
+        };
+
+        for (const node of allNodes) {
+            if (color.get(node) === WHITE) {
+                dfs(node);
+            }
+        }
+
+        if (errors.length > 0) {
+            this.logger.error('Relationship graph cycle validation failed:', { errors });
+            throw this.errorBuilder.buildError(
+                ErrorType.CONFIGURATION,
+                undefined,
+                {
+                    customMessageReference: ErrorCustomMessageReference.RESOURCES_REGISTRY_RELATIONSHIP_VALIDATION_FAILED,
+                    context: {
+                        message: 'Unauthorized cycles detected in the relationship graph',
+                        errors,
+                    }
+                }
+            );
+        }
+
+        this.logDebug(`Validated relationship graph: ${allNodes.size} nodes, ${allResourceRelationships.length} edges, no unauthorized cycles`);
+    }
+
+    /**
+     * Validate that all resources using PostgreSQL have it enabled in app config.
+     * This catches configuration mismatches early at startup.
+     *
+     * Checks:
+     * - Resources with persistenceAdapter: 'postgresql' require postgresql.enabled = true
+     * - Warns if defaultAdapter is 'postgresql' but it's not enabled
+     *
+     * NOTE: In platform mode, AppConfigurationService may not be initialized yet
+     * (platform apps initialize config later in the startup sequence).
+     * In this case, we skip validation and rely on defaults.
+     */
+    protected validatePersistenceAdapterConfiguration(
+        allResourceConfigurations: { [key: string]: AnyResourceConfiguration }
+    ): void {
+        // Skip validation if config service is not initialized (platform mode)
+        // Platform apps initialize AppConfigurationService after resources registry.
+        // Optional chaining: partial/test containers without isInitialized are treated as not ready.
+        if (this.configService?.isInitialized?.() !== true) {
+            this.logger.warn('Skipping persistence adapter validation - config service not yet initialized (platform mode)');
+            return;
+        }
+
+        const errors: string[] = [];
+        const warnings: string[] = [];
+
+        // Get database configuration
+        const config = this.configService.config;
+        const databaseConfig = (config as any)?.database;
+        const defaultAdapter: PersistenceAdapterType = databaseConfig?.defaultAdapter ?? DEFAULT_PERSISTENCE_ADAPTER;
+        const postgresqlEnabled = databaseConfig?.postgresql?.enabled ?? false;
+        const mongodbEnabled = databaseConfig?.mongodb?.enabled ?? true;
+
+        // Check if default adapter is valid
+        if (defaultAdapter === 'postgresql' && !postgresqlEnabled) {
+            warnings.push(
+                `Default persistence adapter is 'postgresql' but PostgreSQL is not enabled in database config. ` +
+                `Set database.postgresql.enabled = true or change defaultAdapter to 'mongodb'.`
+            );
+        }
+
+        if (defaultAdapter === 'mongodb' && !mongodbEnabled) {
+            errors.push(
+                `Default persistence adapter is 'mongodb' but MongoDB is not enabled in database config. ` +
+                `Set database.mongodb.enabled = true or change defaultAdapter to 'postgresql'.`
+            );
+        }
+
+        // Check each resource's persistence adapter
+        for (const [resourceType, resourceConfig] of Object.entries(allResourceConfigurations)) {
+            const adapter: PersistenceAdapterType =
+                (resourceConfig as any).persistenceAdapter ?? defaultAdapter;
+
+            if (adapter === 'postgresql' && !postgresqlEnabled) {
+                errors.push(
+                    `Resource '${resourceType}' requires PostgreSQL (persistenceAdapter: 'postgresql') ` +
+                    `but PostgreSQL is not enabled in database config. ` +
+                    `Either set database.postgresql.enabled = true or remove the persistenceAdapter override.`
+                );
+            }
+
+            if (adapter === 'mongodb' && !mongodbEnabled) {
+                errors.push(
+                    `Resource '${resourceType}' requires MongoDB (persistenceAdapter: 'mongodb') ` +
+                    `but MongoDB is not enabled in database config. ` +
+                    `Either set database.mongodb.enabled = true or change the persistenceAdapter.`
+                );
+            }
+        }
+
+        // Log warnings
+        if (warnings.length > 0) {
+            for (const warning of warnings) {
+                this.logger.warn(warning);
+            }
+        }
+
+        // Throw on errors
+        if (errors.length > 0) {
+            this.logger.error('Persistence adapter configuration validation failed:', { errors });
+            throw this.errorBuilder.buildError(
+                ErrorType.CONFIGURATION,
+                undefined,
+                {
+                    customMessageReference: ErrorCustomMessageReference.RESOURCES_REGISTRY_INITIALIZATION_FAILED,
+                    context: {
+                        reason: 'persistence_adapter_mismatch',
+                        errors
+                    }
+                }
+            );
+        }
+
+        this.logDebug(`Validated persistence adapter configuration for ${Object.keys(allResourceConfigurations).length} resources`);
+    }
+
+    protected generateUrlsForAllResourceConfigurations(
+        allResourceConfigurations: { [key: string]: AnyResourceConfiguration },
+        registry: ResourcesRegistry,
+        allResourceFieldIdentifiers: Record<string, string>
+    ): void {
+
+        let totalApiCallOperations = 0;
+        let totalUrlsGenerated = 0;
+
+        for (const [resourceType, resourceConfig] of Object.entries(allResourceConfigurations)) {
+            try {
+                this.logDebug(`Generating URLs for resource type: ${resourceType}`);
+
+                // Use the URL builder to generate and update URLs
+                ResourcesConfigOperationsUrlsBuilderUtils.updateOperationUrls(
+                    resourceConfig,
+                    allResourceFieldIdentifiers,
+                );
+
+                // Count API_CALL operations for logging
+                const apiCallOps = resourceConfig.operations.filter(op => op.variantType === ResourceOperationVariantType.API_CALL);
+                totalApiCallOperations += apiCallOps.length;
+
+                // Count total URLs generated
+                apiCallOps.forEach(op => {
+                    if ('initiatorInfos' in op && Array.isArray(op.initiatorInfos)) {
+                        totalUrlsGenerated += op.initiatorInfos.length;
+                    }
+                });
+
+            } catch (error) {
+                this.logger.error(`Failed to generate URLs for resource type ${resourceType}`, {
+                    error: error instanceof Error ? error.message : String(error),
+                    resourceType
+                });
+            }
+        }
+
+        this.logDebug('URL generation completed', {
+            totalResourceTypes: Object.keys(allResourceConfigurations).length,
+            totalApiCallOperations,
+            totalUrlsGenerated
+        });
+    }
+
+    /**
+      * Enhance DTOs for all operations in resource configurations
+      */
+    protected enhanceDtosForAllResourceConfigurations(
+        allResourceConfigurations: { [key: string]: AnyResourceConfiguration },
+        registry: ResourcesRegistry,
+        allResourceFieldIdentifiers: Record<string, string>
+    ): void {
+
+
+        for (const [resourceType, resourceConfig] of Object.entries(allResourceConfigurations)) {
+            try {
+                this.logDebug(`\n🚀 Starting DTO enhancement for resource: ${resourceType} (${resourceConfig.operations?.length || 0} operations)`);
+
+                if (!resourceConfig.operations || resourceConfig.operations.length === 0) {
+                    this.logDebug(`⚠️  No operations found for ${resourceType}, skipping...`);
+                    continue;
+                }
+
+                // NOTE: DTOs are already pre-computed by the factory via buildAllOperationDtos.
+                // The factory builds all 6 DTO variants (requestDto, responseDto, summaryDto,
+                // contextDto, internalDto, repositoryDto) with inheritance applied.
+                //
+                // Phase 2.1: Factory now pre-computes all DTOs, so runtime enhancement is no longer needed.
+                // The old buildOperationDtos method only built requestDto/responseDto and would
+                // overwrite the factory's complete DTOs, losing summaryDto, contextDto, internalDto, repositoryDto.
+                //
+                // Operations already have all DTOs from factory - use them as-is.
+                this.logDebug(`ℹ️  DTOs already pre-computed by factory (buildAllOperationDtos with all 6 variants), using factory-built DTOs`);
+                // No need to replace - operations already have all DTOs from factory
+
+                this.logDebug(`✅ Completed DTO enhancement for ${resourceType}`);
+
+            } catch (error) {
+                this.logger.error(`Failed to enhance DTOs for resource type ${resourceType}`, {
+                    error: error instanceof Error ? error.message : String(error),
+                    resourceType
+                });
+            }
+        }
+
+    }
+
+    // ================================
+    // Debug Methods
+    // ================================
+
+    public debugDisplayGeneratedUrls(): void {
+        this.ensureInitialized();
+
+        const registry = this.getResourcesRegistry();
+
+        this.logDebug('\n=== 🌐 GENERATED API URLS DEBUG DISPLAY ===\n');
+
+        const resourceTypes = Object.keys(registry.resourceConfigurations).sort();
+        let totalOperations = 0;
+        let totalUrls = 0;
+
+        for (const resourceType of resourceTypes) {
+            const resourceConfig = registry.resourceConfigurations[resourceType];
+
+            // Filter API_CALL operations
+            const apiCallOperations = resourceConfig.operations.filter(
+                op => op.variantType === ResourceOperationVariantType.API_CALL
+            );
+
+            if (apiCallOperations.length === 0) {
+                continue;
+            }
+
+            this.logDebug(`📋 Resource: ${resourceType}`);
+            this.logDebug(`   Field Identifier: ${resourceConfig.resourceFieldIdentifier}`);
+            this.logDebug(`   Primary Scope: ${resourceConfig.resourcePrimaryScope}`);
+            this.logDebug(`   Parent Relationships: ${resourceConfig.resourceRelationships.parentRelationships.length}`);
+            this.logDebug('   ────────────────────────────────────────────────────────────────────────');
+
+            for (const operation of apiCallOperations) {
+                totalOperations++;
+
+                // Extract operation path using ResourcesConfig_OperationPathUtils
+                const operationPath = ResourcesConfig_OperationPathUtils.extractOperationPath(operation);
+
+                // Stringify operation path using ResourcesConfig_OperationPathUtils
+                const operationPathString = ResourcesConfig_OperationPathUtils.createOperationPathKey(operationPath);
+
+                this.logDebug(`   🔧 Operation Path: ${operationPathString}`);
+
+                // Display URLs if they exist
+                if ('initiatorInfos' in operation && Array.isArray(operation.initiatorInfos) && operation.initiatorInfos.length > 0) {
+                    this.logDebug(`   🌐 Generated URLs (${operation.initiatorInfos.length}):`);
+                    operation.initiatorInfos.forEach((initiatorInfo: ResourceConfiguration_Operation_UrlInitiatorInfo, index: number) => {
+                        const paramInfo = initiatorInfo.parameters?.map((p: ResourceConfiguration_Operation_UrlParameterInfo) => `${p.fieldIdentifier}:${p.resourceType}`).join(', ') || 'none';
+                        const callbackInfo = initiatorInfo.urlCallback ? ` | callback: ${initiatorInfo.urlCallback}` : '';
+                        this.logDebug(`      ${index + 1}. ${operation.httpVerb || 'N/A'} ${initiatorInfo.url}${callbackInfo} [params: ${paramInfo}]`);
+                        totalUrls++;
+                    });
+                } else {
+                    this.logDebug(`   ❌ No URLs generated`);
+                }
+
+                // Additional operation details
+                const details: string[] = [];
+                if ('isBulkOperation' in operation && operation.isBulkOperation) {
+                    details.push('BULK');
+                }
+                if (operation.variantKey) {
+                    details.push(`VARIANT: ${operation.variantKey}`);
+                }
+                if ('isApiKeyAccessDisabled' in operation && operation.isApiKeyAccessDisabled) {
+                    details.push('NO_API_KEY');
+                }
+
+                if (details.length > 0) {
+                    this.logDebug(`   📝 Details: ${details.join(', ')}`);
+                }
+
+                this.logDebug('   ────────────────────────────────────────────────────────────────────────');
+            }
+
+            this.logDebug(''); // Empty line between resources
+        }
+
+        this.logDebug(`📊 Summary:`);
+        this.logDebug(`   Total Resource Types: ${resourceTypes.length}`);
+        this.logDebug(`   Total API_CALL Operations: ${totalOperations}`);
+        this.logDebug(`   Total Generated URLs: ${totalUrls}`);
+        this.logDebug(`   Average URLs per Operation: ${totalOperations > 0 ? (totalUrls / totalOperations).toFixed(2) : '0'}`);
+        this.logDebug('\n=== END URL DEBUG DISPLAY ===\n');
+    }
+
+
+    public debugDisplayResourceUrls(resourceType: ResourceType): void {
+        this.ensureInitialized();
+
+        const registry = this.getResourcesRegistry();
+        const resourceConfig = registry.resourceConfigurations[resourceType];
+
+        if (!resourceConfig) {
+            this.logDebug(`❌ Resource type '${resourceType}' not found in registry`);
+            return;
+        }
+
+        this.logDebug(`\n=== 🔍 URL PATTERNS FOR RESOURCE: ${resourceType} ===\n`);
+
+        // Show resource details
+        this.logDebug(`📋 Resource Details:`);
+        this.logDebug(`   Identifier: ${resourceConfig.resourceIdentifier}`);
+        this.logDebug(`   Field Identifier: ${resourceConfig.resourceFieldIdentifier}`);
+        this.logDebug(`   Primary Scope: ${resourceConfig.resourcePrimaryScope}`);
+        this.logDebug(`   System Resource: ${resourceConfig.isSystemResource}`);
+
+        // Show parent relationships
+        const parentRels = resourceConfig.resourceRelationships.parentRelationships;
+        if (parentRels.length > 0) {
+            this.logDebug(`\n🔗 Parent Relationships (${parentRels.length}):`);
+            parentRels.forEach((rel, index) => {
+                const scope = rel.isPrimaryScope ? ' [PRIMARY SCOPE]' : '';
+                const requirement = rel.parentResourceRequirement === ResourceParentResourceRequirement.OPTIONAL ? ' [OPTIONAL]' : ' [MANDATORY]';
+                this.logDebug(`   ${index + 1}. ${rel.resourceType1} → ${rel.resourceType2}${scope}${requirement}`);
+            });
+        }
+
+        // Show API_CALL operations
+        const apiCallOps = resourceConfig.operations.filter(
+            op => op.variantType === ResourceOperationVariantType.API_CALL
+        );
+
+        if (apiCallOps.length > 0) {
+            this.logDebug(`\n🔧 API_CALL Operations (${apiCallOps.length}):`);
+
+            apiCallOps.forEach((operation, index) => {
+                const operationPath = ResourcesConfig_OperationPathUtils.extractOperationPath(operation);
+                const pathString = ResourcesConfig_OperationPathUtils.createOperationPathKey(operationPath);
+
+                this.logDebug(`\n   ${index + 1}. ${pathString}`);
+
+                if ('initiatorInfos' in operation && Array.isArray(operation.initiatorInfos)) {
+                    operation.initiatorInfos.forEach((initiatorInfo: ResourceConfiguration_Operation_UrlInitiatorInfo, urlIndex: number) => {
+                        const paramInfo = initiatorInfo.parameters?.map((p: ResourceConfiguration_Operation_UrlParameterInfo) => `${p.fieldIdentifier}:${p.resourceType}`).join(', ') || 'none';
+                        const callbackInfo = initiatorInfo.urlCallback ? ` | callback: ${initiatorInfo.urlCallback}` : '';
+                        this.logDebug(`      ${operation.httpVerb || 'N/A'} ${initiatorInfo.url}${callbackInfo} [params: ${paramInfo}]`);
+                    });
+                }
+            });
+        } else {
+            this.logDebug('\n❌ No API_CALL operations found');
+        }
+
+                this.logDebug(`\n=== END RESOURCE URL PATTERNS ===\n`);
+    }
+
+    public debugDisplayGeneratedDtos(resourceFilter: ResourceType[] = []): void {
+        this.ensureInitialized();
+
+        const registry = this.getResourcesRegistry();
+
+        ResourcesConfigOperationsDtosBuilderUtils.debugDisplayGeneratedDtos(
+            registry.resourceConfigurations,
+            resourceFilter
+        );
+    }
+
+    /**
+     * Auto-register a limitCheck on a resource's CREATE default variant.
+     * Called by FeatureDefinitionRegistryBackendService during startup for
+     * limit features with `countResource`.
+     *
+     * Only adds the limitCheck if:
+     * - The resource exists in the registry
+     * - The resource has a CREATE operation
+     * - No explicit limitChecks already references this featureId
+     *
+     * @param resourceType - The resource type whose CREATE operation should get the limitCheck
+     * @param featureId - The feature identifier for the limit check
+     * @returns true if the limitCheck was added, false if skipped
+     */
+    public addAutoLimitCheck(resourceType: string, featureId: string): boolean {
+        this.ensureInitialized();
+
+        const registry = this.getResourcesRegistry();
+        const resourceConfig = registry.resourceConfigurations[resourceType as ResourceType];
+
+        if (!resourceConfig) {
+            this.logDebug(`addAutoLimitCheck: resource ${resourceType} not found in registry, skipping`);
+            return false;
+        }
+
+        // Find the CREATE default API_CALL operation
+        const createOp = resourceConfig.operations.find(
+            (op: any) => op.operationIdentifier === CoreResourceOperation.CREATE && op.variantType === ResourceOperationVariantType.API_CALL && op.isDefault
+        );
+
+        if (!createOp) {
+            this.logDebug(`addAutoLimitCheck: resource ${resourceType} has no CREATE default API_CALL variant, skipping`);
+            return false;
+        }
+
+        // Cast to mutable shape for auto-registration mutation.
+        // At startup, operations have already been normalized by the factory, so requiredFeatures
+        // is in full form `{ features?, mode?, limitChecks? }` (never the shorthand `string[]`).
+        const mutableOp = createOp as { requiredFeatures?: { features?: string[]; mode?: string; limitChecks?: Array<{ featureId: string; increment?: number }> } };
+
+        // Check if this featureId is already in limitChecks
+        if (mutableOp.requiredFeatures?.limitChecks?.some(lc => lc.featureId === featureId)) {
+            this.logDebug(`addAutoLimitCheck: resource ${resourceType} CREATE already has limitCheck for ${featureId}, skipping`);
+            return false;
+        }
+
+        // Add the limitCheck
+        if (!mutableOp.requiredFeatures) {
+            mutableOp.requiredFeatures = {};
+        }
+        if (!mutableOp.requiredFeatures.limitChecks) {
+            mutableOp.requiredFeatures.limitChecks = [];
+        }
+        mutableOp.requiredFeatures.limitChecks.push({ featureId });
+
+        this.logDebug(`addAutoLimitCheck: added limitCheck for ${featureId} on ${resourceType}.CREATE`);
+        return true;
+    }
+}
+