semantic-ds-toolkit/dist/test/pack-loading-debug.test.js

Performance-first semantic layer for modern data stacks - Stable Column Anchors & intelligent inference

import { CIDRegistry } from '../src/registry/cid-registry';
import { PackManager } from '../src/registry/pack-manager';
import { PackValidator } from '../src/registry/pack-validator';
import * as fs from 'fs';
import * as path from 'path';
describe('Pack Loading Debug', () => {
    let registry;
    let packManager;
    let validator;
    beforeEach(() => {
        registry = new CIDRegistry();
        packManager = new PackManager(registry);
        validator = new PackValidator();
    });
    it('should debug pack loading from YAML files', async () => {
        const packsDir = path.join(__dirname, '../semantics/packs');
        console.log('Looking for packs in:', packsDir);
        console.log('Directory exists:', fs.existsSync(packsDir));
        if (fs.existsSync(packsDir)) {
            const files = fs.readdirSync(packsDir);
            console.log('Files in directory:', files);
            const packFiles = files.filter(f => f.endsWith('.yml'));
            console.log('YAML files found:', packFiles);
            for (const packFile of packFiles) {
                const packPath = path.join(packsDir, packFile);
                const yamlContent = fs.readFileSync(packPath, 'utf8');
                console.log(`\n--- Processing ${packFile} ---`);
                const validationResult = validator.validateYamlStructure(yamlContent);
                console.log('Validation result:', {
                    valid: validationResult.valid,
                    errorCount: validationResult.errors.length,
                    errors: validationResult.errors.map(e => e.message)
                });
                if (validationResult.valid) {
                    const packData = (await import('yaml')).parse(yamlContent);
                    console.log('Parsed pack data:', {
                        pack: packData.pack,
                        version: packData.version,
                        depends_on: packData.depends_on,
                        conceptCount: packData.concepts?.length || 0
                    });
                    const pack = PackValidator.createPackFromValidatedData(packData);
                    const loadResult = await packManager.loadPack(pack);
                    console.log('Load result:', {
                        success: loadResult.success,
                        errorCount: loadResult.errors.length,
                        errors: loadResult.errors,
                        loadOrder: loadResult.loadOrder
                    });
                }
            }
            console.log('\nFinal registry state:');
            console.log('Loaded packs:', registry.getLoadedPacks());
            console.log('All concepts count:', registry.getAllConcepts().length);
        }
    });
});
//# sourceMappingURL=pack-loading-debug.test.js.map