@slingr/cli 0.0.3 → 0.0.4

package/dist/commands/ds.js

@@ -42,13 +42,21 @@ const node_path_1 = __importDefault(require("node:path"));
 const child_process_1 = require("child_process");
 const yaml = __importStar(require("js-yaml"));
 const jsonlLoader_js_1 = require("../utils/jsonlLoader.js");
+const checkFramework_js_1 = require("../utils/checkFramework.js");
+const datasourceParser_js_1 = require("../utils/datasourceParser.js");
+const infraFileParser_js_1 = require("../utils/infraFileParser.js");
 class Ds extends core_1.Command {
-    static description = 'Manage datasets for datasources';
+    static description = 'Manage datasets and inspect datasources';
     static examples = [
-        'slingr ds postgres load',
-        'slingr ds postgres load custom-dataset',
-        'slingr ds mysql load default',
-        'slingr ds postgres reset',
+        '<%= config.bin %> <%= command.id %> mainDs load',
+        '<%= config.bin %> <%= command.id %> postgres load custom-dataset',
+        '<%= config.bin %> <%= command.id %> mainDs load --includeModels=User,Project',
+        '<%= config.bin %> <%= command.id %> mainDs load --includeModels="User,Project"',
+        '<%= config.bin %> <%= command.id %> mainDs load --excludeModels=TestData',
+        '<%= config.bin %> <%= command.id %> mainDs load --verbose',
+        '<%= config.bin %> <%= command.id %> postgres reset',
+        '<%= config.bin %> <%= command.id %> mainDs indexes',
+        '<%= config.bin %> <%= command.id %> mainDs indexes --verbose',
     ];
     static args = {
         datasource: core_1.Args.string({
@@ -56,8 +64,8 @@ class Ds extends core_1.Command {
             required: true,
         }),
         action: core_1.Args.string({
-            description: 'Action to perform (load or reset)',
-            options: ['load', 'reset'],
+            description: 'Action to perform (load, reset, or indexes)',
+            options: ['load', 'reset', 'indexes'],
             required: true,
         }),
         dataset: core_1.Args.string({
@@ -66,58 +74,88 @@ class Ds extends core_1.Command {
             default: 'default',
         }),
     };
+    static flags = {
+        includeModels: core_1.Flags.string({
+            description: 'Comma-separated list of model names to load. Only these models will be loaded (overrides datasetOptions.json). Use --includeModels=Model1,Model2 or --includeModels "Model1,Model2" syntax.',
+            required: false,
+        }),
+        excludeModels: core_1.Flags.string({
+            description: 'Comma-separated list of model names to skip. All other models will be loaded (overrides datasetOptions.json). Use --excludeModels=Model1,Model2 or --excludeModels "Model1,Model2" syntax.',
+            required: false,
+        }),
+        verbose: core_1.Flags.boolean({
+            description: 'Show detailed logs during dataset loading. Without this flag, only success and validation error messages are displayed.',
+            required: false,
+            default: false,
+            char: 'v',
+        }),
+    };
     async run() {
-        const { args } = await this.parse(Ds);
+        const { args, flags } = await this.parse(Ds);
         const { datasource, action, dataset } = args;
+        // Reject conflicting filter flags early — before any app/Docker checks
+        if (flags['includeModels'] && flags['excludeModels']) {
+            this.error('--includeModels and --excludeModels are mutually exclusive. Provide only one to avoid ambiguous behaviour.');
+        }
         // Verify we're in a Slingr app directory
         const pkgPath = node_path_1.default.join(process.cwd(), 'package.json');
         if (!(await fs_extra_1.default.pathExists(pkgPath))) {
             this.error("Not in a Slingr application directory. Please run this command from your app's root directory.");
         }
-        // Check if the datasource exists
-        const dsPath = node_path_1.default.join(process.cwd(), 'src', 'dataSources', `${datasource}.ts`);
-        if (!(await fs_extra_1.default.pathExists(dsPath))) {
-            this.error(`Datasource ${datasource} not found. Expected file at: ${dsPath}`);
+        // Verify the datasource file exists (no auto-discovery)
+        try {
+            await (0, datasourceParser_js_1.discoverDatasourceFile)(datasource);
+        }
+        catch (error) {
+            this.error(error.message);
         }
         try {
             switch (action) {
                 case 'load':
                     // Prepare the environment before loading
-                    await this.prepareEnvironment();
-                    await this.loadDataset(datasource, dataset);
+                    await this.prepareEnvironment(flags['verbose']);
+                    await this.loadDataset(datasource, dataset, flags['includeModels'], flags['excludeModels'], flags['verbose']);
                     break;
                 case 'reset':
                     await this.resetDatasource(datasource);
                     break;
+                case 'indexes':
+                    await this.showIndexes(datasource, flags['verbose']);
+                    break;
                 default:
                     this.error(`Unknown action: ${action}`);
             }
         }
         catch (error) {
-            this.error(`Failed to ${action} dataset: ${error.message}`);
+            this.error(`Failed to ${action}: ${error.message}`);
         }
     }
-    async generateCode() {
+    async generateCode(verbose = false) {
         // Compile TypeScript code
-        this.log('Compiling TypeScript code...');
-        (0, child_process_1.execSync)('npm run build', { stdio: 'inherit' });
+        if (verbose) {
+            this.log('Compiling TypeScript code...');
+        }
+        const backendPath = (0, checkFramework_js_1.getBackendPath)();
+        // Clean compiled backend output to remove stale files from deleted models
+        await fs_extra_1.default.remove(node_path_1.default.join(backendPath, 'dist', 'src'));
+        await fs_extra_1.default.remove(node_path_1.default.join(backendPath, 'dist', 'generated'));
+        (0, child_process_1.execSync)('npm run build', { stdio: verbose ? 'inherit' : 'pipe', cwd: backendPath });
     }
-    async ensureDatabaseDependencies(datasource) {
-        // Get the datasource type by reading the datasource file
-        const dsPath = node_path_1.default.join(process.cwd(), 'src', 'dataSources', `${datasource}.ts`);
+    async ensureDatabaseDependencies(datasource, verbose = false) {
+        // Get the datasource type by reading and parsing the datasource file
+        const backendPath = (0, checkFramework_js_1.getBackendPath)();
+        const dsPath = node_path_1.default.join(backendPath, 'src', 'dataSources', `${datasource}.ts`);
         const content = await fs_extra_1.default.readFile(dsPath, 'utf-8');
-        // Extract database type from the configuration
-        const typeMatch = content.match(/type:\s*['"]([^'"]+)['"]/);
-        if (!typeMatch) {
-            this.log('Could not determine database type from datasource configuration');
+        const parsedConfig = (0, infraFileParser_js_1.parseDataSourceFile)(content, datasource);
+        if (!parsedConfig) {
+            if (verbose) {
+                this.log('Could not determine database type from datasource configuration');
+            }
             return;
         }
-        let dbType = typeMatch[1].toLowerCase();
-        if (dbType === 'postgresql') {
-            dbType = 'postgres';
-        }
+        const dbType = parsedConfig.type;
         // Check package.json for required dependencies
-        const packageJsonPath = node_path_1.default.join(process.cwd(), 'package.json');
+        const packageJsonPath = node_path_1.default.join(backendPath, 'package.json');
         const packageJson = await fs_extra_1.default.readJSON(packageJsonPath);
         const dependencies = {
             ...packageJson.dependencies,
@@ -139,93 +177,139 @@ class Ds extends core_1.Command {
         }
         // Install the required package if missing
         if (packageToInstall) {
-            this.log(`Installing required database driver: ${packageToInstall}`);
+            if (verbose) {
+                this.log(`Installing required database driver: ${packageToInstall}`);
+            }
             try {
                 (0, child_process_1.execSync)(`npm install ${packageToInstall}`, {
-                    stdio: 'inherit',
-                    cwd: process.cwd(),
+                    stdio: verbose ? 'inherit' : 'pipe',
+                    cwd: backendPath,
                 });
-                this.log(`Successfully installed ${packageToInstall}`);
+                if (verbose) {
+                    this.log(`Successfully installed ${packageToInstall}`);
+                }
             }
             catch (error) {
                 this.error(`Failed to install ${packageToInstall}: ${error.message}`);
             }
         }
         else {
-            this.log(`Database driver for ${dbType} is already installed`);
+            if (verbose) {
+                this.log(`Database driver for ${dbType} is already installed`);
+            }
         }
     }
-    async prepareEnvironment() {
-        // Check if we have package.json with slingr-framework dependency
-        const packageJsonPath = node_path_1.default.join(process.cwd(), 'package.json');
-        const packageJson = await fs_extra_1.default.readJSON(packageJsonPath);
-        if (!packageJson.dependencies?.['slingr-framework']) {
+    async prepareEnvironment(verbose = false) {
+        // Check if we have package.json with @slingr/framework-backend dependency
+        if (!(await (0, checkFramework_js_1.hasSlingrFramework)())) {
             this.error('This directory does not contain a Slingr application.');
         }
-        // Check if node_modules exists, if not tell user to install dependencies
-        const nodeModulesPath = node_path_1.default.join(process.cwd(), 'node_modules');
-        if (!(await fs_extra_1.default.pathExists(nodeModulesPath))) {
-            this.error('Dependencies not found. Please run "npm install" first to install the required dependencies.');
-        }
-        // Check if slingr-framework is specifically installed
-        const frameworkPath = node_path_1.default.join(nodeModulesPath, 'slingr-framework');
-        if (!(await fs_extra_1.default.pathExists(frameworkPath))) {
-            this.error('slingr-framework not found in node_modules. Please run "npm install" to install dependencies.');
+        // Check if @slingr/framework-backend is installed (handles both workspace and non-workspace scenarios)
+        const frameworkPath = await (0, checkFramework_js_1.getFrameworkPath)();
+        if (!frameworkPath) {
+            this.error('@slingr/framework-backend not found. Please run "npm install" to install dependencies.');
         }
         // Generate code
-        await this.generateCode();
+        await this.generateCode(verbose);
     }
-    async loadDataset(datasource, dataset) {
-        this.log(`Loading dataset '${dataset}' into datasource '${datasource}'...`);
+    async loadDataset(datasource, dataset, includeModelsFlag, excludeModelsFlag, verbose = false) {
+        if (verbose) {
+            this.log(`Loading dataset '${dataset}' into datasource '${datasource}'...`);
+        }
+        const backendPath = (0, checkFramework_js_1.getBackendPath)();
         // Check if the dataset directory exists using the convention: dataSourceName-datasetName
-        const datasetPath = node_path_1.default.join(process.cwd(), 'src', 'datasets', `${datasource}-${dataset}`);
+        const datasetPath = node_path_1.default.join(backendPath, 'src', 'datasets', `${datasource}-${dataset}`);
         if (!(await fs_extra_1.default.pathExists(datasetPath))) {
             this.error(`Dataset not found at: ${datasetPath}`);
         }
+        // Normalize a list of model names: strip optional .jsonl extension users may have included
+        const normalizeModelNames = (names) => names.map(s => s.trim().replace(/\.jsonl$/i, '')).filter(Boolean);
+        // Split a string by comma or space (handles both --flag=A,B and PowerShell's --flag A,B → "A B")
+        const splitModelNames = (str) => {
+            // First try splitting by comma
+            const parts = str
+                .split(',')
+                .map(s => s.trim())
+                .filter(Boolean);
+            // If no commas found (single element), try splitting by space
+            // This handles PowerShell's array literal interpretation: --flag A,B → "A B"
+            if (parts.length === 1 && parts[0].includes(' ')) {
+                return parts[0].split(/\s+/).filter(Boolean);
+            }
+            return parts;
+        };
+        // Read datasetOptions.json if it exists (provides defaults that CLI flags override)
+        let includeModels;
+        let excludeModels;
+        const optionsFilePath = node_path_1.default.join(datasetPath, 'datasetOptions.json');
+        if (await fs_extra_1.default.pathExists(optionsFilePath)) {
+            try {
+                const options = await fs_extra_1.default.readJSON(optionsFilePath);
+                if (Array.isArray(options.includeModels) && options.includeModels.length > 0) {
+                    includeModels = normalizeModelNames(options.includeModels);
+                }
+                if (Array.isArray(options.excludeModels) && options.excludeModels.length > 0) {
+                    excludeModels = normalizeModelNames(options.excludeModels);
+                }
+                if (verbose) {
+                    this.log(`📋 Loaded dataset options from datasetOptions.json`);
+                }
+            }
+            catch {
+                this.warn('Could not parse datasetOptions.json — ignoring it.');
+            }
+        }
+        // CLI flags override options from the file
+        if (includeModelsFlag) {
+            includeModels = normalizeModelNames(splitModelNames(includeModelsFlag));
+        }
+        if (excludeModelsFlag) {
+            excludeModels = normalizeModelNames(splitModelNames(excludeModelsFlag));
+        }
+        // When both are set (regardless of source), excludeModels is redundant because the
+        // loader already honours includeModels first.  Warn and clear to avoid confusing output.
+        if (includeModels && includeModels.length > 0 && excludeModels && excludeModels.length > 0) {
+            this.warn('Both includeModels and excludeModels are set. excludeModels will be ignored because includeModels takes priority.');
+            excludeModels = undefined;
+        }
+        if (verbose && includeModels && includeModels.length > 0) {
+            this.log(`🔍 Including only models: ${includeModels.join(', ')}`);
+        }
+        if (verbose && excludeModels && excludeModels.length > 0) {
+            this.log(`🚫 Excluding models: ${excludeModels.join(', ')}`);
+        }
+        // Validate Docker is running and database container is available (do this early)
+        await this.validateDockerInfrastructure(datasource, verbose);
+        // Ensure the required database dependencies are installed
+        await this.ensureDatabaseDependencies(datasource, verbose);
+        // Load the datasource configuration using the new parser
+        // This intelligently discovers whatever is exported from the datasource file
+        const dsConfig = await (0, datasourceParser_js_1.loadDataSourceFromFile)(datasource);
         // Initialize the JSONL loader
         const loader = new jsonlLoader_js_1.JsonlDatasetLoader();
         // Path to the compiled JavaScript files
-        const distPath = node_path_1.default.join(process.cwd(), 'dist');
+        const distPath = node_path_1.default.join(backendPath, 'dist');
         // Auto-discover models from compiled JS files
-        const modelMap = await (0, jsonlLoader_js_1.discoverModels)(distPath);
+        const modelMap = await (0, jsonlLoader_js_1.discoverModels)(distPath, verbose);
         if (Object.keys(modelMap).length === 0) {
-            this.error('No models found. Please ensure your models are compiled (run npm run build) and extend BaseModel.');
-        }
-        this.log(`Discovered ${Object.keys(modelMap).length} models:`, Object.keys(modelMap));
-        // Load dataset using the new JSONL loader
-        const loadResults = await loader.loadDataset({
-            datasetPath,
-            modelMap,
-            validateRecords: true,
-            verbose: true,
-        });
-        if (loadResults.length === 0) {
-            this.error('No compatible JSONL files found or no models matched the file names.');
-        }
-        // Import the datasource module from compiled JS
-        const dsModulePath = node_path_1.default.join(process.cwd(), 'dist', 'dataSources', `${datasource}.js`);
-        const dsModule = require(dsModulePath);
-        // Try different possible export names
-        let dsConfig = dsModule[`${datasource}`];
-        if (!dsConfig) {
-            dsConfig = dsModule[`mainDs`];
+            this.error('No models found. Please ensure your models are compiled (run npm run build) and extend BaseDataModel.');
         }
-        if (!dsConfig) {
-            const availableExports = Object.keys(dsModule);
-            this.error(`Could not find datasource instance. Tried: '${datasource}', '${datasource}DataSource'. Available exports: ${availableExports.join(', ')} in ${dsModulePath}`);
+        if (verbose) {
+            this.log(`Discovered ${Object.keys(modelMap).length} models:`, Object.keys(modelMap));
         }
-        // Validate Docker is running and PostgreSQL container is available
-        await this.validateDockerInfrastructure(datasource);
-        // Ensure the required database dependencies are installed
-        await this.ensureDatabaseDependencies(datasource);
-        // Initialize the datasource with its configuration
+        // Initialize the datasource after models are discovered so TypeORM metadata is registered
+        // This also enables loading missing references from DB during dataset validation
         try {
-            this.log(`Attempting to connect to database: ${JSON.stringify(dsConfig.getOptions(), null, 2)}`);
+            if (verbose) {
+                this.log(`Attempting to connect to database: ${JSON.stringify(dsConfig.getOptions(), null, 2)}`);
+            }
             await dsConfig.initialize();
         }
         catch (error) {
             const errorMessage = error.message;
-            this.log(`Connection failed with error: ${errorMessage}`);
+            if (verbose) {
+                this.log(`Connection failed with error: ${errorMessage}`);
+            }
             // Check if docker-compose.yml exists
             const dockerComposePath = node_path_1.default.join(process.cwd(), 'docker-compose.yml');
             const hasDockerCompose = await fs_extra_1.default.pathExists(dockerComposePath);
@@ -257,40 +341,62 @@ class Ds extends core_1.Command {
                     this.error(`Cannot connect to database server. The database infrastructure exists but is not running.\n\nTo fix this, run one of the following commands:\n  - slingr run (to start the full application with infrastructure)\n  - docker-compose up -d (to start just the infrastructure services)`);
                 }
                 else {
-                    this.error(`Cannot connect to database server. The database infrastructure has not been set up yet.\n\nTo fix this, you have two options:\n\n1. Simple option:\n  - slingr run (automatically generates infrastructure and starts the application)\n\n2. Step-by-step option:\n  - slingr infra:update --all (to generate docker-compose.yml and infrastructure files)\n  - Then run: slingr run OR docker-compose up -d`);
+                    this.error(`Cannot connect to database server. No docker-compose.yml found.\n\nPlease ensure:\n  1. Database server is running\n  2. Connection details in ${datasource}.ts are correct`);
                 }
             }
-            // Check for connection refused errors
+            // Check for specific connection errors
             if (isConnectionRefused(error)) {
                 if (hasDockerCompose) {
-                    this.error(`Cannot connect to database server. The database infrastructure exists but is not running.\n\nTo fix this, run one of the following commands:\n  - slingr run (to start the full application with infrastructure)\n  - docker-compose up -d (to start just the infrastructure services)`);
+                    this.error(`Cannot connect to database server (connection refused). The database infrastructure exists but is not running.\n\nTo fix this, run one of the following commands:\n  - slingr run (to start the full application with infrastructure)\n  - docker-compose up -d (to start just the infrastructure services)`);
                 }
                 else {
-                    this.error(`Cannot connect to database server. The database infrastructure has not been set up yet.\n\nTo fix this, you have two options:\n\n1. Simple option:\n  - slingr run (automatically generates infrastructure and starts the application)\n\n2. Step-by-step option:\n  - slingr infra:update --all (to generate docker-compose.yml and infrastructure files)\n  - Then run: slingr run OR docker-compose up -d`);
+                    this.error(`Cannot connect to database server (connection refused). No docker-compose.yml found.\n\nPlease ensure:\n  1. Database server is running and accepting connections\n  2. Connection details (host/port) in ${datasource}.ts are correct`);
                 }
             }
-            // Check for database not found errors
-            if (errorMessage.includes('database') && errorMessage.includes('does not exist')) {
-                this.error(`Database infrastructure not found. The database server is not running or the database does not exist.\n\nTo fix this, run the following command:\n  - slingr run (to start the full application with infrastructure)`);
-            }
-            // Re-throw other errors
-            throw error;
+            // Generic fallback error
+            this.error(`Failed to initialize database: ${errorMessage}`);
+        }
+        // Load dataset using the new JSONL loader
+        // Pass the dataSource so missing references can be loaded from DB during validation
+        const loadResults = await loader.loadDataset({
+            datasetPath,
+            modelMap,
+            validateRecords: true,
+            verbose,
+            includeModels,
+            excludeModels,
+            dataSource: dsConfig,
+        });
+        if (loadResults.length === 0) {
+            this.error('No compatible JSONL files found or no models matched the file names.');
         }
         const dataSource = dsConfig.getTypeOrmDataSource();
         if (!dataSource || !dataSource.isInitialized) {
             this.error('DataSource failed to initialize');
         }
-        this.log('DataSource initialized successfully');
+        if (verbose) {
+            this.log('DataSource initialized successfully');
+        }
         // Process each load result using TypeORM repositories (database-agnostic)
         try {
             // Use the new generic loader method
-            await loader.loadDatasetToDatabase(loadResults, dsConfig, true);
+            await loader.loadDatasetToDatabase(loadResults, dsConfig, verbose);
             // Print summary
-            const totalSuccess = loadResults.reduce((sum, r) => sum + r.successCount, 0);
-            const totalErrors = loadResults.reduce((sum, r) => sum + r.errorCount, 0);
-            this.log(`
-🎉 Successfully loaded dataset '${dataset}' into datasource '${datasource}'`);
-            this.log(`📈 Summary: ${totalSuccess} records loaded, ${totalErrors} errors`);
+            const totalLoaded = loadResults.reduce((sum, r) => sum + r.successCount, 0);
+            const totalValidationErrors = loadResults.reduce((sum, r) => sum + r.errorCount, 0);
+            const totalSaved = loadResults.reduce((sum, r) => sum + r.saveSuccessCount, 0);
+            const totalSaveErrors = loadResults.reduce((sum, r) => sum + r.saveErrorCount, 0);
+            this.log(`
+🎉 Dataset loading complete for '${dataset}' into datasource '${datasource}'`);
+            this.log(`
+📈 Summary:
+   • ${totalLoaded} records loaded from JSONL files
+   • ${totalValidationErrors} validation errors
+   • ${totalSaved} records successfully saved to database
+   • ${totalSaveErrors} save errors`);
+            if (totalSaveErrors > 0) {
+                this.log(`\n⚠️  Some records failed to save. Run with --verbose flag for detailed error information.`);
+            }
         }
         catch (error) {
             this.error(`Failed to load dataset: ${error.message}`);
@@ -299,16 +405,20 @@ class Ds extends core_1.Command {
             // Clean up by closing the datasource connection
             if (dataSource.isInitialized) {
                 // Add delay to ensure all operations complete
-                this.log('⏳ Finalizing database operations...');
+                if (verbose) {
+                    this.log('⏳ Finalizing database operations...');
+                }
                 await new Promise(resolve => setTimeout(resolve, 2000));
                 await dataSource.destroy();
-                this.log('🔌 Database connection closed');
+                if (verbose) {
+                    this.log('🔌 Database connection closed');
+                }
             }
         }
     }
     async resetDatasource(datasource) {
         this.log(`Resetting datasource '${datasource}' infrastructure...`);
-        this.ensureDockerIsRunning();
+        await this.ensureDockerIsRunning();
         const composeFile = node_path_1.default.join(process.cwd(), 'docker-compose.yml');
         if (!(await fs_extra_1.default.pathExists(composeFile))) {
             this.error(`Docker infrastructure not found. Missing docker-compose.yml file.\n\nTo fix this, run one of the following commands:\n  - slingr infra:update --all (to generate infrastructure files)\n  - slingr run (to automatically generate and start infrastructure)`);
@@ -370,12 +480,13 @@ class Ds extends core_1.Command {
         await this.validateDockerInfrastructure(datasource);
         this.log(`✅ Datasource '${datasource}' has been reset successfully.`);
     }
-    ensureDockerIsRunning() {
+    async ensureDockerIsRunning() {
+        const { ensureDockerIsRunning } = await import('../utils/dockerManager.js');
         try {
-            (0, child_process_1.execSync)('docker info', { stdio: 'pipe' });
+            await ensureDockerIsRunning('slingr ds');
         }
         catch (error) {
-            this.error(`Docker is not running. Please start Docker Desktop before running dataset commands.\n\nThe dataset command requires Docker to run the PostgreSQL infrastructure.`);
+            this.error(error.message);
         }
     }
     getComposeCommand() {
@@ -392,7 +503,6 @@ class Ds extends core_1.Command {
                 this.error('Docker Compose is not installed. Please install Docker Compose to manage infrastructure services.');
             }
         }
-        return 'docker compose';
     }
     listComposeServices(composeCommand, cwd) {
         try {
@@ -484,44 +594,263 @@ class Ds extends core_1.Command {
             }
         }
     }
+    // ─── Indexes action ────────────────────────────────────────────────────────
+    async showIndexes(datasource, verbose = false) {
+        if (verbose) {
+            this.log(`Retrieving indexes for datasource '${datasource}'...`);
+        }
+        // Parse datasource config first so we can make engine-specific decisions
+        // (e.g. skip Docker validation entirely for SQLite)
+        const backendPath = (0, checkFramework_js_1.getBackendPath)();
+        const dsPath = node_path_1.default.join(backendPath, 'src', 'dataSources', `${datasource}.ts`);
+        const content = await fs_extra_1.default.readFile(dsPath, 'utf-8');
+        const dsOptions = (0, infraFileParser_js_1.parseDataSourceFile)(content, datasource);
+        if (!dsOptions) {
+            this.error(`Could not parse datasource configuration from '${datasource}.ts'.`);
+        }
+        const isSqlite = dsOptions.type === 'sqlite' || dsOptions.type === 'better-sqlite3';
+        // Docker validation and driver install are only needed for server-based databases.
+        // SQLite is a local file (or :memory:) — no container required.
+        if (!isSqlite) {
+            await this.validateDockerInfrastructure(datasource, verbose);
+            await this.ensureDatabaseDependencies(datasource, verbose);
+        }
+        const { DataSource: TypeOrmDataSource } = await import('typeorm');
+        const connectionConfig = {
+            type: dsOptions.type,
+            synchronize: false,
+            logging: false,
+        };
+        if (dsOptions.type === 'sqlite') {
+            connectionConfig.database = dsOptions.database || ':memory:';
+        }
+        else {
+            if (dsOptions.host)
+                connectionConfig.host = dsOptions.host;
+            if (dsOptions.port)
+                connectionConfig.port = dsOptions.port;
+            if (dsOptions.username !== undefined)
+                connectionConfig.username = dsOptions.username;
+            if (dsOptions.password !== undefined)
+                connectionConfig.password = dsOptions.password;
+            if (dsOptions.database)
+                connectionConfig.database = dsOptions.database;
+        }
+        let dataSource;
+        try {
+            if (verbose) {
+                this.log('Connecting to database (read-only, no schema sync)...');
+            }
+            dataSource = new TypeOrmDataSource(connectionConfig);
+            await dataSource.initialize();
+        }
+        catch (error) {
+            this.error(`Failed to connect to database: ${error.message}`);
+        }
+        try {
+            const indexes = await this.queryIndexes(dataSource, verbose);
+            if (indexes.length === 0) {
+                this.log('No indexes found in the database (excluding primary keys).');
+                return;
+            }
+            // Print the indexes grouped by table
+            this.printIndexTable(indexes);
+        }
+        finally {
+            if (dataSource.isInitialized) {
+                await dataSource.destroy();
+                if (verbose) {
+                    this.log('Database connection closed');
+                }
+            }
+        }
+    }
+    async queryIndexes(dataSource, verbose) {
+        const dbType = dataSource.options.type;
+        if (verbose) {
+            this.log(`Querying indexes for database type: ${dbType}`);
+        }
+        switch (dbType) {
+            case 'postgres':
+                return this.queryPostgresIndexes(dataSource);
+            case 'mysql':
+            case 'mariadb':
+                return this.queryMysqlIndexes(dataSource);
+            case 'sqlite':
+            case 'better-sqlite3':
+                return this.querySqliteIndexes(dataSource);
+            default:
+                this.error(`Unsupported database type for index inspection: ${dbType}`);
+        }
+    }
+    async queryPostgresIndexes(dataSource) {
+        const queryRunner = dataSource.createQueryRunner();
+        try {
+            const rows = await queryRunner.query(`
+        SELECT
+          t.relname   AS table_name,
+          i.relname   AS index_name,
+          array_agg(a.attname ORDER BY array_position(ix.indkey, a.attnum)) AS columns,
+          ix.indisunique AS is_unique,
+          am.amname   AS algorithm
+        FROM pg_index ix
+        JOIN pg_class t ON t.oid = ix.indrelid
+        JOIN pg_class i ON i.oid = ix.indexrelid
+        JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = ANY(ix.indkey)
+        JOIN pg_am am ON am.oid = i.relam
+        JOIN pg_namespace n ON n.oid = t.relnamespace
+        WHERE n.nspname = 'public'
+          AND NOT ix.indisprimary
+        GROUP BY t.relname, i.relname, ix.indisunique, am.amname
+        ORDER BY t.relname, i.relname
+      `);
+            return rows.map((row) => ({
+                tableName: row.table_name,
+                indexName: row.index_name,
+                columns: Array.isArray(row.columns) ? row.columns : [row.columns],
+                isUnique: row.is_unique,
+                algorithm: row.algorithm,
+            }));
+        }
+        finally {
+            await queryRunner.release();
+        }
+    }
+    async queryMysqlIndexes(dataSource) {
+        const queryRunner = dataSource.createQueryRunner();
+        try {
+            const rows = await queryRunner.query(`
+        SELECT
+          TABLE_NAME   AS table_name,
+          INDEX_NAME   AS index_name,
+          GROUP_CONCAT(COLUMN_NAME ORDER BY SEQ_IN_INDEX) AS columns_csv,
+          CASE WHEN NON_UNIQUE = 0 THEN 1 ELSE 0 END     AS is_unique,
+          INDEX_TYPE   AS algorithm
+        FROM INFORMATION_SCHEMA.STATISTICS
+        WHERE TABLE_SCHEMA = DATABASE()
+          AND INDEX_NAME != 'PRIMARY'
+        GROUP BY TABLE_NAME, INDEX_NAME, NON_UNIQUE, INDEX_TYPE
+        ORDER BY TABLE_NAME, INDEX_NAME
+      `);
+            return rows.map((row) => ({
+                tableName: row.table_name,
+                indexName: row.index_name,
+                columns: row.columns_csv.split(','),
+                isUnique: row.is_unique === 1 || row.is_unique === '1',
+                algorithm: row.algorithm.toLowerCase(),
+            }));
+        }
+        finally {
+            await queryRunner.release();
+        }
+    }
+    async querySqliteIndexes(dataSource) {
+        const queryRunner = dataSource.createQueryRunner();
+        const indexes = [];
+        try {
+            const tables = await queryRunner.query(`SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%'`);
+            for (const table of tables) {
+                const indexList = await queryRunner.query(`PRAGMA index_list("${table.name}")`);
+                for (const idx of indexList) {
+                    // Skip auto-created indexes for primary keys
+                    if (idx.origin === 'pk')
+                        continue;
+                    const indexInfo = await queryRunner.query(`PRAGMA index_info("${idx.name}")`);
+                    const columns = indexInfo.map(col => col.name);
+                    indexes.push({
+                        tableName: table.name,
+                        indexName: idx.name,
+                        columns,
+                        isUnique: idx.unique === 1,
+                        algorithm: 'btree',
+                    });
+                }
+            }
+            return indexes;
+        }
+        finally {
+            await queryRunner.release();
+        }
+    }
+    printIndexTable(indexes) {
+        // Calculate column widths
+        const headers = { table: 'TABLE', index: 'INDEX', columns: 'COLUMNS', unique: 'UNIQUE', algorithm: 'ALGORITHM' };
+        let tableW = headers.table.length;
+        let indexW = headers.index.length;
+        let columnsW = headers.columns.length;
+        const uniqueW = headers.unique.length;
+        let algoW = headers.algorithm.length;
+        for (const idx of indexes) {
+            tableW = Math.max(tableW, idx.tableName.length);
+            indexW = Math.max(indexW, idx.indexName.length);
+            columnsW = Math.max(columnsW, idx.columns.join(', ').length);
+            algoW = Math.max(algoW, idx.algorithm.length);
+        }
+        const pad = (str, width) => str.padEnd(width);
+        const separator = '-'.repeat(tableW + indexW + columnsW + uniqueW + algoW + 16);
+        this.log('');
+        this.log(`  ${pad(headers.table, tableW)}  ${pad(headers.index, indexW)}  ${pad(headers.columns, columnsW)}  ${pad(headers.unique, uniqueW)}  ${headers.algorithm}`);
+        this.log(`  ${separator}`);
+        let currentTable = '';
+        for (const idx of indexes) {
+            const tableDisplay = idx.tableName !== currentTable ? idx.tableName : '';
+            currentTable = idx.tableName;
+            this.log(`  ${pad(tableDisplay, tableW)}  ${pad(idx.indexName, indexW)}  ${pad(idx.columns.join(', '), columnsW)}  ${pad(idx.isUnique ? 'Yes' : 'No', uniqueW)}  ${idx.algorithm}`);
+        }
+        this.log('');
+        this.log(`  ${indexes.length} index${indexes.length !== 1 ? 'es' : ''} found.`);
+    }
     /**
-     * Validate that Docker is running and PostgreSQL container is available
+     * Validate that Docker is running and the database container is available.
+     * Only call this for server-based databases (postgres, mysql, mariadb).
+     * SQLite does not need Docker and should bypass this method entirely.
      */
-    async validateDockerInfrastructure(datasource) {
-        // Check if Docker is running
+    async validateDockerInfrastructure(datasource, verbose = false) {
+        // Check if Docker is running (auto-start if needed)
+        const { ensureDockerIsRunning } = await import('../utils/dockerManager.js');
         try {
-            (0, child_process_1.execSync)('docker info', { stdio: 'pipe' });
+            await ensureDockerIsRunning('slingr ds');
         }
         catch (error) {
-            this.error(`Docker is not running. Please start Docker Desktop before running dataset commands.\n\nThe dataset command requires Docker to run the PostgreSQL infrastructure.`);
+            this.error(error.message);
         }
         // Check if docker-compose.yml exists
         const dockerComposePath = node_path_1.default.join(process.cwd(), 'docker-compose.yml');
         if (!(await fs_extra_1.default.pathExists(dockerComposePath))) {
             this.error(`Docker infrastructure not found. Missing docker-compose.yml file.\n\nTo fix this, run one of the following commands:\n  - slingr infra:update --all (to generate infrastructure files)\n  - slingr run (to automatically generate and start infrastructure)`);
         }
-        // Check if PostgreSQL container is running
+        // Get the correct Docker Compose command
+        const composeCommand = this.getComposeCommand();
+        // Check if the database container is running
         const serviceName = `${datasource}-db`; // Docker service name format
+        if (verbose) {
+            this.log(`Verifying database container '${serviceName}' is running...`);
+        }
         try {
-            const result = (0, child_process_1.execSync)(`docker-compose ps -q ${serviceName}`, {
+            const result = (0, child_process_1.execSync)(`${composeCommand} ps -q ${serviceName}`, {
                 stdio: 'pipe',
                 encoding: 'utf8',
             });
             if (!result.trim()) {
-                this.error(`PostgreSQL container '${serviceName}' is not running.\n\nTo fix this, run one of the following commands:\n  - slingr run (to start the full application with infrastructure)\n  - docker-compose up -d ${serviceName} (to start just the PostgreSQL service)`);
+                this.error(`Database container '${serviceName}' is not running.\n\nTo fix this, run one of the following commands:\n  - slingr run (to start the full application with infrastructure)\n  - ${composeCommand} up -d ${serviceName} (to start just the ${datasource} service)`);
+            }
+            if (verbose) {
+                this.log(`✅ Database container '${serviceName}' exists`);
             }
             // Verify the container is actually running (not just exists)
-            const statusResult = (0, child_process_1.execSync)(`docker-compose ps ${serviceName}`, {
+            const statusResult = (0, child_process_1.execSync)(`${composeCommand} ps ${serviceName}`, {
                 stdio: 'pipe',
                 encoding: 'utf8',
             });
             if (!statusResult.includes('Up')) {
-                this.error(`PostgreSQL container '${serviceName}' exists but is not running.\n\nTo fix this, run one of the following commands:\n  - slingr run (to start the full application with infrastructure)\n  - docker-compose up -d ${serviceName} (to start just the PostgreSQL service)`);
+                this.error(`Database container '${serviceName}' exists but is not running.\n\nTo fix this, run one of the following commands:\n  - slingr run (to start the full application with infrastructure)\n  - ${composeCommand} up -d ${serviceName} (to start just the ${datasource} service)`);
+            }
+            if (verbose) {
+                this.log(`✅ Docker infrastructure validated: database container '${serviceName}' is running`);
             }
-            this.log(`✅ Docker infrastructure validated: PostgreSQL container '${serviceName}' is running`);
         }
         catch (error) {
-            this.error(`Could not verify PostgreSQL container status.\n\nTo fix this, run one of the following commands:\n  - slingr run (to start the full application with infrastructure)\n  - docker-compose up -d (to start all infrastructure services)`);
+            this.error(`Could not verify database container status.\n\nTo fix this, run one of the following commands:\n  - slingr run (to start the full application with infrastructure)\n  - ${composeCommand} up -d (to start all infrastructure services)`);
         }
     }
 }