@solidxai/core 0.1.10-beta.25 → 0.1.10-beta.26

package/dist/services/module-metadata-explorer.service.d.ts

@@ -0,0 +1,161 @@
+import { ModuleMetadataHelperService } from '../helpers/module-metadata-helper.service';
+import { MetadataExplorerReferencesQueryDto } from '../dtos/metadata-explorer-references-query.dto';
+import { MetadataExplorerSearchQueryDto } from '../dtos/metadata-explorer-search-query.dto';
+import { MetadataExplorerWriteDto } from '../dtos/metadata-explorer-write.dto';
+type MetadataExplorerSectionType = 'object' | 'array';
+type MetadataValidationIssue = {
+    path: string;
+    message: string;
+    severity: 'error' | 'warning';
+};
+type MetadataSearchMatch = {
+    path: string;
+    sectionKey: string | null;
+    matchType: 'key' | 'value';
+    valueType: string;
+    preview: string;
+};
+export declare class ModuleMetadataExplorerService {
+    private readonly moduleMetadataHelperService;
+    private readonly logger;
+    constructor(moduleMetadataHelperService: ModuleMetadataHelperService);
+    getManifest(moduleName: string): Promise<{
+        moduleName: string;
+        filePath: string;
+        lastModifiedAt: string;
+        sections: {
+            exists: boolean;
+            itemCount: number;
+            nodeCount: number;
+            preview: string;
+            key: string;
+            title: string;
+            jsonPath: string;
+            type: MetadataExplorerSectionType;
+            description: string;
+        }[];
+        validation: {
+            valid: boolean;
+            issues: MetadataValidationIssue[];
+        };
+    }>;
+    getDocument(moduleName: string): Promise<{
+        moduleName: string;
+        filePath: string;
+        lastModifiedAt: string;
+        value: any;
+        validation: {
+            valid: boolean;
+            issues: MetadataValidationIssue[];
+        };
+    }>;
+    updateDocument(moduleName: string, dto: MetadataExplorerWriteDto): Promise<{
+        moduleName: string;
+        filePath: string;
+        lastModifiedAt: string;
+        value: any;
+        validation: {
+            valid: boolean;
+            issues: MetadataValidationIssue[];
+        };
+    }>;
+    validateDocument(moduleName: string, dto?: MetadataExplorerWriteDto): Promise<{
+        valid: boolean;
+        issues: MetadataValidationIssue[];
+        moduleName: string;
+        filePath: string;
+    }>;
+    getSection(moduleName: string, sectionKey: string): Promise<{
+        moduleName: string;
+        filePath: string;
+        lastModifiedAt: string;
+        section: {
+            key: string;
+            title: string;
+            jsonPath: string;
+            type: MetadataExplorerSectionType;
+            description: string;
+            exists: boolean;
+            itemCount: number;
+            nodeCount: number;
+            value: any;
+        };
+        validation: {
+            valid: boolean;
+            issues: MetadataValidationIssue[];
+        };
+    }>;
+    updateSection(moduleName: string, sectionKey: string, dto: MetadataExplorerWriteDto): Promise<{
+        moduleName: string;
+        filePath: string;
+        lastModifiedAt: string;
+        section: {
+            key: string;
+            title: string;
+            jsonPath: string;
+            type: MetadataExplorerSectionType;
+            description: string;
+            exists: boolean;
+            itemCount: number;
+            nodeCount: number;
+            value: any;
+        };
+        validation: {
+            valid: boolean;
+            issues: MetadataValidationIssue[];
+        };
+    }>;
+    validateSection(moduleName: string, sectionKey: string, dto?: MetadataExplorerWriteDto): Promise<{
+        valid: boolean;
+        issues: MetadataValidationIssue[];
+        moduleName: string;
+        sectionKey: string;
+        section: {
+            key: string;
+            title: string;
+            jsonPath: string;
+            type: MetadataExplorerSectionType;
+        };
+    }>;
+    search(moduleName: string, query: MetadataExplorerSearchQueryDto): Promise<{
+        moduleName: string;
+        query: string;
+        sectionKey: string;
+        meta: {
+            totalMatches: number;
+            returned: number;
+            limit: number;
+            offset: number;
+        };
+        matches: MetadataSearchMatch[];
+    }>;
+    findReferences(moduleName: string, query: MetadataExplorerReferencesQueryDto): Promise<{
+        moduleName: string;
+        needle: string;
+        sectionKey: string;
+        meta: {
+            totalMatches: number;
+            returned: number;
+            limit: number;
+            offset: number;
+        };
+        matches: MetadataSearchMatch[];
+    }>;
+    private loadMetadataDocument;
+    private writeMetadataDocument;
+    private getSectionDefinition;
+    private buildSectionResponse;
+    private validateDocumentValue;
+    private validateSectionValue;
+    private getValueAtPath;
+    private setValueAtPath;
+    private countNodes;
+    private buildPreview;
+    private collectMatches;
+    private matchesNeedle;
+    private resolveSectionKey;
+    private joinPath;
+    private assertValueProvided;
+}
+export {};
+//# sourceMappingURL=module-metadata-explorer.service.d.ts.map

package/dist/services/module-metadata-explorer.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module-metadata-explorer.service.d.ts","sourceRoot":"","sources":["../../src/services/module-metadata-explorer.service.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,2BAA2B,EAAE,MAAM,4CAA4C,CAAC;AACzF,OAAO,EAAE,kCAAkC,EAAE,MAAM,gDAAgD,CAAC;AACpG,OAAO,EAAE,8BAA8B,EAAE,MAAM,4CAA4C,CAAC;AAC5F,OAAO,EAAE,wBAAwB,EAAE,MAAM,qCAAqC,CAAC;AAE/E,KAAK,2BAA2B,GAAG,QAAQ,GAAG,OAAO,CAAC;AAUtD,KAAK,uBAAuB,GAAG;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAC;CACjC,CAAC;AAEF,KAAK,mBAAmB,GAAG;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,SAAS,EAAE,KAAK,GAAG,OAAO,CAAC;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;CACnB,CAAC;AAuBF,qBACa,6BAA6B;IAIlC,OAAO,CAAC,QAAQ,CAAC,2BAA2B;IAHhD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAkD;gBAGpD,2BAA2B,EAAE,2BAA2B;IASvE,WAAW,CAAC,UAAU,EAAE,MAAM;;;;;;;;;iBAxD/B,MAAM;mBACJ,MAAM;sBACH,MAAM;kBACV,2BAA2B;yBACpB,MAAM;;;;;;;IAkFb,WAAW,CAAC,UAAU,EAAE,MAAM;;;;;;;;;;IAkB9B,cAAc,CAAC,UAAU,EAAE,MAAM,EAAE,GAAG,EAAE,wBAAwB;;;;;;;;;;IAkBhE,gBAAgB,CAAC,UAAU,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,wBAAwB;;;;;;IAkBnE,UAAU,CAAC,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;IAqBjD,aAAa,CAAC,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,GAAG,EAAE,wBAAwB;;;;;;;;;;;;;;;;;;;;IA0BnF,eAAe,CAAC,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,wBAAwB;;;;;;;;;;;;IA0BtF,MAAM,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,8BAA8B;;;;;;;;;;;;IA2ChE,cAAc,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,kCAAkC;;;;;;;;;;;;YA2CpE,oBAAoB;YAiCpB,qBAAqB;IAWnC,OAAO,CAAC,oBAAoB;IAc5B,OAAO,CAAC,oBAAoB;IAoB5B,OAAO,CAAC,qBAAqB;IA8C7B,OAAO,CAAC,oBAAoB;IAkD5B,OAAO,CAAC,cAAc;IAWtB,OAAO,CAAC,cAAc;IAqBtB,OAAO,CAAC,UAAU;IAiBlB,OAAO,CAAC,YAAY;IAiBpB,OAAO,CAAC,cAAc;IAyEtB,OAAO,CAAC,aAAa;IAarB,OAAO,CAAC,iBAAiB;IAgBzB,OAAO,CAAC,QAAQ;IAWhB,OAAO,CAAC,mBAAmB;CAK9B"}

package/dist/services/module-metadata-explorer.service.js

@@ -0,0 +1,485 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+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 __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var ModuleMetadataExplorerService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModuleMetadataExplorerService = void 0;
+const common_1 = require("@nestjs/common");
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const disallow_in_production_decorator_1 = require("../decorators/disallow-in-production.decorator");
+const module_metadata_helper_service_1 = require("../helpers/module-metadata-helper.service");
+const metadata_explorer_write_dto_1 = require("../dtos/metadata-explorer-write.dto");
+const SECTION_DEFINITIONS = [
+    { key: 'module', title: 'Module', jsonPath: 'moduleMetadata', type: 'object', description: 'Top-level module metadata excluding nested models.' },
+    { key: 'models', title: 'Models', jsonPath: 'moduleMetadata.models', type: 'array', description: 'Model metadata definitions for the module.' },
+    { key: 'roles', title: 'Roles', jsonPath: 'roles', type: 'array', description: 'Role metadata definitions.' },
+    { key: 'users', title: 'Users', jsonPath: 'users', type: 'array', description: 'Seed users and user-role assignments.' },
+    { key: 'permissions', title: 'Permissions', jsonPath: 'permissions', type: 'array', description: 'Permission declarations and explicit additions.' },
+    { key: 'actions', title: 'Actions', jsonPath: 'actions', type: 'array', description: 'Action metadata definitions.' },
+    { key: 'menus', title: 'Menus', jsonPath: 'menus', type: 'array', description: 'Menu item metadata definitions.' },
+    { key: 'views', title: 'Views', jsonPath: 'views', type: 'array', description: 'List, form, kanban, tree, and related view metadata.' },
+    { key: 'emailTemplates', title: 'Email Templates', jsonPath: 'emailTemplates', type: 'array', description: 'Email template metadata.' },
+    { key: 'smsTemplates', title: 'SMS Templates', jsonPath: 'smsTemplates', type: 'array', description: 'SMS template metadata.' },
+    { key: 'mediaStorageProviders', title: 'Media Storage Providers', jsonPath: 'mediaStorageProviders', type: 'array', description: 'Configured media storage providers.' },
+    { key: 'savedFilters', title: 'Saved Filters', jsonPath: 'savedFilters', type: 'array', description: 'Saved filter definitions.' },
+    { key: 'securityRules', title: 'Security Rules', jsonPath: 'securityRules', type: 'array', description: 'Security rule definitions.' },
+    { key: 'listOfValues', title: 'List Of Values', jsonPath: 'listOfValues', type: 'array', description: 'List of values entries.' },
+    { key: 'dashboards', title: 'Dashboards', jsonPath: 'dashboards', type: 'array', description: 'Dashboard metadata definitions.' },
+    { key: 'testing', title: 'Testing', jsonPath: 'testing', type: 'object', description: 'Testing roles, users, specs, and scenarios.' },
+    { key: 'scheduledJobs', title: 'Scheduled Jobs', jsonPath: 'scheduledJobs', type: 'array', description: 'Scheduled job metadata definitions.' },
+    { key: 'modelSequences', title: 'Model Sequences', jsonPath: 'modelSequences', type: 'array', description: 'Model sequence definitions.' },
+];
+let ModuleMetadataExplorerService = ModuleMetadataExplorerService_1 = class ModuleMetadataExplorerService {
+    constructor(moduleMetadataHelperService) {
+        this.moduleMetadataHelperService = moduleMetadataHelperService;
+        this.logger = new common_1.Logger(ModuleMetadataExplorerService_1.name);
+    }
+    async getManifest(moduleName) {
+        const { document, filePath, stats } = await this.loadMetadataDocument(moduleName);
+        const validation = this.validateDocumentValue(document);
+        const sections = SECTION_DEFINITIONS.map((definition) => {
+            const value = this.getValueAtPath(document, definition.jsonPath);
+            return {
+                ...definition,
+                exists: value !== undefined,
+                itemCount: Array.isArray(value) ? value.length : undefined,
+                nodeCount: this.countNodes(value),
+                preview: this.buildPreview(value, 96),
+            };
+        });
+        return {
+            moduleName,
+            filePath,
+            lastModifiedAt: stats.mtime.toISOString(),
+            sections,
+            validation,
+        };
+    }
+    async getDocument(moduleName) {
+        const { document, filePath, stats } = await this.loadMetadataDocument(moduleName);
+        return {
+            moduleName,
+            filePath,
+            lastModifiedAt: stats.mtime.toISOString(),
+            value: document,
+            validation: this.validateDocumentValue(document),
+        };
+    }
+    async updateDocument(moduleName, dto) {
+        this.assertValueProvided(dto?.value);
+        const validation = this.validateDocumentValue(dto.value);
+        if (!validation.valid) {
+            throw new common_1.BadRequestException(validation);
+        }
+        const filePath = await this.moduleMetadataHelperService.getModuleMetadataFilePath(moduleName);
+        await this.writeMetadataDocument(filePath, dto.value);
+        return this.getDocument(moduleName);
+    }
+    async validateDocument(moduleName, dto) {
+        const filePath = await this.moduleMetadataHelperService.getModuleMetadataFilePath(moduleName);
+        const value = dto && Object.prototype.hasOwnProperty.call(dto, 'value')
+            ? dto.value
+            : (await this.loadMetadataDocument(moduleName)).document;
+        return {
+            moduleName,
+            filePath,
+            ...this.validateDocumentValue(value),
+        };
+    }
+    async getSection(moduleName, sectionKey) {
+        const definition = this.getSectionDefinition(sectionKey);
+        const { document, filePath, stats } = await this.loadMetadataDocument(moduleName);
+        const value = this.getValueAtPath(document, definition.jsonPath);
+        return {
+            moduleName,
+            filePath,
+            lastModifiedAt: stats.mtime.toISOString(),
+            section: this.buildSectionResponse(definition, value),
+            validation: this.validateSectionValue(definition, value),
+        };
+    }
+    async updateSection(moduleName, sectionKey, dto) {
+        this.assertValueProvided(dto?.value);
+        const definition = this.getSectionDefinition(sectionKey);
+        const sectionValidation = this.validateSectionValue(definition, dto.value);
+        if (!sectionValidation.valid) {
+            throw new common_1.BadRequestException(sectionValidation);
+        }
+        const { document, filePath } = await this.loadMetadataDocument(moduleName);
+        this.setValueAtPath(document, definition.jsonPath, dto.value);
+        const documentValidation = this.validateDocumentValue(document);
+        if (!documentValidation.valid) {
+            throw new common_1.BadRequestException(documentValidation);
+        }
+        await this.writeMetadataDocument(filePath, document);
+        return this.getSection(moduleName, sectionKey);
+    }
+    async validateSection(moduleName, sectionKey, dto) {
+        const definition = this.getSectionDefinition(sectionKey);
+        const value = dto && Object.prototype.hasOwnProperty.call(dto, 'value')
+            ? dto.value
+            : this.getValueAtPath((await this.loadMetadataDocument(moduleName)).document, definition.jsonPath);
+        return {
+            moduleName,
+            sectionKey,
+            section: {
+                key: definition.key,
+                title: definition.title,
+                jsonPath: definition.jsonPath,
+                type: definition.type,
+            },
+            ...this.validateSectionValue(definition, value),
+        };
+    }
+    async search(moduleName, query) {
+        const needle = `${query?.query ?? ''}`.trim();
+        if (!needle) {
+            throw new common_1.BadRequestException('Search query is required.');
+        }
+        const { document } = await this.loadMetadataDocument(moduleName);
+        const targetSection = query?.sectionKey ? this.getSectionDefinition(query.sectionKey) : null;
+        const searchRoot = targetSection ? this.getValueAtPath(document, targetSection.jsonPath) : document;
+        const rootPath = targetSection ? targetSection.jsonPath : '';
+        const limit = query?.limit ?? 10;
+        const offset = query?.offset ?? 0;
+        const matches = this.collectMatches(searchRoot, rootPath, {
+            needle,
+            exact: query?.exact ?? false,
+            limit,
+            offset,
+            previewLength: query?.previewLength ?? 120,
+            matchKeys: true,
+            matchValues: true,
+        });
+        return {
+            moduleName,
+            query: needle,
+            sectionKey: targetSection?.key ?? null,
+            meta: {
+                totalMatches: matches.total,
+                returned: matches.items.length,
+                limit,
+                offset,
+            },
+            matches: matches.items,
+        };
+    }
+    async findReferences(moduleName, query) {
+        const needle = `${query?.needle ?? ''}`.trim();
+        if (!needle) {
+            throw new common_1.BadRequestException('Reference needle is required.');
+        }
+        const { document } = await this.loadMetadataDocument(moduleName);
+        const targetSection = query?.sectionKey ? this.getSectionDefinition(query.sectionKey) : null;
+        const searchRoot = targetSection ? this.getValueAtPath(document, targetSection.jsonPath) : document;
+        const rootPath = targetSection ? targetSection.jsonPath : '';
+        const limit = query?.limit ?? 10;
+        const offset = query?.offset ?? 0;
+        const matches = this.collectMatches(searchRoot, rootPath, {
+            needle,
+            exact: query?.exact ?? true,
+            limit,
+            offset,
+            previewLength: 140,
+            matchKeys: query?.matchKeys ?? true,
+            matchValues: query?.matchValues ?? true,
+            excludePath: query?.excludePath,
+        });
+        return {
+            moduleName,
+            needle,
+            sectionKey: targetSection?.key ?? null,
+            meta: {
+                totalMatches: matches.total,
+                returned: matches.items.length,
+                limit,
+                offset,
+            },
+            matches: matches.items,
+        };
+    }
+    async loadMetadataDocument(moduleName) {
+        const filePath = await this.moduleMetadataHelperService.getModuleMetadataFilePath(moduleName);
+        if (!filePath) {
+            throw new common_1.NotFoundException(`Unable to resolve metadata file for module: ${moduleName}`);
+        }
+        try {
+            const [raw, stats] = await Promise.all([
+                fs.readFile(filePath, 'utf-8'),
+                fs.stat(filePath),
+            ]);
+            const document = JSON.parse(raw);
+            return { document, filePath, stats };
+        }
+        catch (error) {
+            if (error?.code === 'ENOENT') {
+                throw new common_1.NotFoundException(`Metadata file not found for module: ${moduleName}`);
+            }
+            if (error instanceof SyntaxError) {
+                throw new common_1.BadRequestException(`Metadata file for module ${moduleName} contains invalid JSON.`);
+            }
+            this.logger.error(`Failed to load metadata for module ${moduleName}`, error);
+            throw error;
+        }
+    }
+    async writeMetadataDocument(filePath, document) {
+        await fs.mkdir(path.dirname(filePath), { recursive: true });
+        await fs.writeFile(filePath, `${JSON.stringify(document, null, 2)}\n`, 'utf-8');
+    }
+    getSectionDefinition(sectionKey) {
+        const definition = SECTION_DEFINITIONS.find((item) => item.key === sectionKey);
+        if (!definition) {
+            throw new common_1.NotFoundException(`Metadata explorer section not found: ${sectionKey}`);
+        }
+        return definition;
+    }
+    buildSectionResponse(definition, value) {
+        return {
+            key: definition.key,
+            title: definition.title,
+            jsonPath: definition.jsonPath,
+            type: definition.type,
+            description: definition.description,
+            exists: value !== undefined,
+            itemCount: Array.isArray(value) ? value.length : undefined,
+            nodeCount: this.countNodes(value),
+            value,
+        };
+    }
+    validateDocumentValue(document) {
+        const issues = [];
+        if (!document || typeof document !== 'object' || Array.isArray(document)) {
+            issues.push({
+                path: '',
+                message: 'Metadata document must be a JSON object.',
+                severity: 'error',
+            });
+        }
+        const moduleMetadata = document?.moduleMetadata;
+        if (!moduleMetadata || typeof moduleMetadata !== 'object' || Array.isArray(moduleMetadata)) {
+            issues.push({
+                path: 'moduleMetadata',
+                message: 'moduleMetadata must be present as an object.',
+                severity: 'error',
+            });
+        }
+        if (moduleMetadata && !Array.isArray(moduleMetadata.models)) {
+            issues.push({
+                path: 'moduleMetadata.models',
+                message: 'moduleMetadata.models must be an array.',
+                severity: 'error',
+            });
+        }
+        for (const definition of SECTION_DEFINITIONS) {
+            const sectionValue = this.getValueAtPath(document, definition.jsonPath);
+            const sectionValidation = this.validateSectionValue(definition, sectionValue, true);
+            issues.push(...sectionValidation.issues);
+        }
+        return {
+            valid: issues.every((issue) => issue.severity !== 'error'),
+            issues,
+        };
+    }
+    validateSectionValue(definition, value, allowUndefined = false) {
+        const issues = [];
+        if (value === undefined) {
+            if (!allowUndefined) {
+                issues.push({
+                    path: definition.jsonPath,
+                    message: `${definition.title} is missing from the metadata document.`,
+                    severity: 'error',
+                });
+            }
+            return {
+                valid: issues.every((issue) => issue.severity !== 'error'),
+                issues,
+            };
+        }
+        const isArray = Array.isArray(value);
+        if (definition.type === 'array' && !isArray) {
+            issues.push({
+                path: definition.jsonPath,
+                message: `${definition.title} must be an array.`,
+                severity: 'error',
+            });
+        }
+        if (definition.type === 'object' && (value === null || typeof value !== 'object' || isArray)) {
+            issues.push({
+                path: definition.jsonPath,
+                message: `${definition.title} must be an object.`,
+                severity: 'error',
+            });
+        }
+        return {
+            valid: issues.every((issue) => issue.severity !== 'error'),
+            issues,
+        };
+    }
+    getValueAtPath(source, jsonPath) {
+        if (!jsonPath)
+            return source;
+        return jsonPath.split('.').reduce((acc, key) => (acc == null ? undefined : acc[key]), source);
+    }
+    setValueAtPath(target, jsonPath, value) {
+        const parts = jsonPath.split('.');
+        let current = target;
+        for (let index = 0; index < parts.length - 1; index++) {
+            const part = parts[index];
+            if (!current[part] || typeof current[part] !== 'object' || Array.isArray(current[part])) {
+                current[part] = {};
+            }
+            current = current[part];
+        }
+        current[parts[parts.length - 1]] = value;
+    }
+    countNodes(value) {
+        if (value === undefined || value === null)
+            return 0;
+        if (Array.isArray(value)) {
+            return value.reduce((sum, item) => sum + this.countNodes(item), 1);
+        }
+        if (typeof value === 'object') {
+            return Object.values(value).reduce((sum, item) => sum + this.countNodes(item), 1);
+        }
+        return 1;
+    }
+    buildPreview(value, maxLength) {
+        if (value === undefined)
+            return '';
+        const normalized = typeof value === 'string'
+            ? value
+            : JSON.stringify(value);
+        if (!normalized)
+            return '';
+        return normalized.length > maxLength ? `${normalized.slice(0, maxLength)}...` : normalized;
+    }
+    collectMatches(root, rootPath, opts) {
+        const results = [];
+        const normalizedNeedle = opts.exact ? opts.needle : opts.needle.toLowerCase();
+        const visit = (value, currentPath) => {
+            if (value === undefined)
+                return;
+            if (Array.isArray(value)) {
+                value.forEach((item, index) => {
+                    visit(item, this.joinPath(currentPath, `${index}`));
+                });
+                return;
+            }
+            if (value && typeof value === 'object') {
+                Object.entries(value).forEach(([key, child]) => {
+                    const childPath = this.joinPath(currentPath, key);
+                    if (opts.matchKeys && this.matchesNeedle(key, normalizedNeedle, opts.exact) && childPath !== opts.excludePath) {
+                        results.push({
+                            path: childPath,
+                            sectionKey: this.resolveSectionKey(childPath),
+                            matchType: 'key',
+                            valueType: 'key',
+                            preview: this.buildPreview(child, opts.previewLength),
+                        });
+                    }
+                    visit(child, childPath);
+                });
+                return;
+            }
+            if (!opts.matchValues)
+                return;
+            const comparable = value == null ? '' : `${value}`;
+            if (this.matchesNeedle(comparable, normalizedNeedle, opts.exact) && currentPath !== opts.excludePath) {
+                results.push({
+                    path: currentPath,
+                    sectionKey: this.resolveSectionKey(currentPath),
+                    matchType: 'value',
+                    valueType: typeof value,
+                    preview: this.buildPreview(value, opts.previewLength),
+                });
+            }
+        };
+        visit(root, rootPath);
+        return {
+            total: results.length,
+            items: results.slice(opts.offset, opts.offset + opts.limit),
+        };
+    }
+    matchesNeedle(value, normalizedNeedle, exact) {
+        if (exact) {
+            return value === normalizedNeedle;
+        }
+        return value.toLowerCase().includes(normalizedNeedle);
+    }
+    resolveSectionKey(jsonPath) {
+        const sorted = [...SECTION_DEFINITIONS].sort((a, b) => b.jsonPath.length - a.jsonPath.length);
+        const matched = sorted.find((section) => jsonPath === section.jsonPath
+            || jsonPath.startsWith(`${section.jsonPath}.`)
+            || jsonPath.startsWith(`${section.jsonPath}[`));
+        return matched?.key ?? null;
+    }
+    joinPath(base, next) {
+        if (!base)
+            return /^\d+$/.test(next) ? `[${next}]` : next;
+        return /^\d+$/.test(next) ? `${base}[${next}]` : `${base}.${next}`;
+    }
+    assertValueProvided(value) {
+        if (value === undefined) {
+            throw new common_1.BadRequestException('A JSON value payload is required.');
+        }
+    }
+};
+exports.ModuleMetadataExplorerService = ModuleMetadataExplorerService;
+__decorate([
+    (0, disallow_in_production_decorator_1.DisallowInProduction)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, metadata_explorer_write_dto_1.MetadataExplorerWriteDto]),
+    __metadata("design:returntype", Promise)
+], ModuleMetadataExplorerService.prototype, "updateDocument", null);
+__decorate([
+    (0, disallow_in_production_decorator_1.DisallowInProduction)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, metadata_explorer_write_dto_1.MetadataExplorerWriteDto]),
+    __metadata("design:returntype", Promise)
+], ModuleMetadataExplorerService.prototype, "updateSection", null);
+exports.ModuleMetadataExplorerService = ModuleMetadataExplorerService = ModuleMetadataExplorerService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [module_metadata_helper_service_1.ModuleMetadataHelperService])
+], ModuleMetadataExplorerService);
+//# sourceMappingURL=module-metadata-explorer.service.js.map