@hypequery/cli 1.1.2 → 1.2.0

package/dist/commands/init.js

@@ -1,388 +1,355 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 import { mkdir, writeFile, readFile, access } from 'node:fs/promises';
 import path from 'node:path';
 import ora from 'ora';
 import { logger } from '../utils/logger.js';
-import { promptClickHouseConnection, promptOutputDirectory, promptGenerateExample, promptTableSelection, confirmOverwrite, promptRetry, promptContinueWithoutDb, } from '../utils/prompts.js';
+import { promptClickHouseConnection, promptOutputDirectory, promptInitStyle, promptGenerateExample, promptTableSelection, promptDatasetTableSelection, confirmOverwrite, promptRetry, promptContinueWithoutDb, } from '../utils/prompts.js';
 import { validateConnection, getTableCount, getTables, } from '../utils/detect-database.js';
 import { hasEnvFile, hasGitignore } from '../utils/find-files.js';
 import { generateEnvTemplate, appendToEnv } from '../templates/env.js';
 import { generateClientTemplate } from '../templates/client.js';
 import { generateQueriesTemplate } from '../templates/queries.js';
+import { generateApiTemplate } from '../templates/api.js';
+import { generateDatasetsPlaceholderTemplate } from '../templates/datasets.js';
 import { appendToGitignore } from '../templates/gitignore.js';
 import { getTypeGenerator } from '../generators/index.js';
+import { generateDatasets } from '../generators/dataset-generator.js';
 import { installScaffoldDependencies } from '../utils/dependency-installer.js';
-function resolveConnectionConfig(options) {
-    return __awaiter(this, void 0, void 0, function () {
-        var required;
-        var _a;
-        return __generator(this, function (_b) {
-            if (options.noInteractive) {
-                required = function (keys) {
-                    var values = Array.isArray(keys) ? keys : [keys];
-                    var value = values.map(function (key) { return process.env[key]; }).find(Boolean);
-                    if (!value) {
-                        throw new Error("Missing ".concat(values.join(' or '), ". Provide ClickHouse connection info via environment variables when using --no-interactive."));
-                    }
-                    return value;
-                };
-                return [2 /*return*/, {
-                        host: required(['CLICKHOUSE_URL', 'CLICKHOUSE_HOST']),
-                        database: required('CLICKHOUSE_DATABASE'),
-                        username: required(['CLICKHOUSE_USERNAME', 'CLICKHOUSE_USER']),
-                        password: (_a = process.env.CLICKHOUSE_PASSWORD) !== null && _a !== void 0 ? _a : '',
-                    }];
+function normalizeInitStyle(style) {
+    return style === 'datasets' ? 'datasets' : 'queries';
+}
+function normalizeAuthMode(auth) {
+    if (!auth || auth === 'none') {
+        return 'none';
+    }
+    if (auth === 'context') {
+        return 'context';
+    }
+    throw new Error(`Unsupported auth mode "${auth}". Use "none" or "context".`);
+}
+function parseTableList(value) {
+    const parsed = value
+        ?.split(',')
+        .map((table) => table.trim())
+        .filter(Boolean);
+    return parsed && parsed.length > 0 ? parsed : undefined;
+}
+async function resolveConnectionConfig(options) {
+    if (options.noInteractive) {
+        const required = (keys) => {
+            const values = Array.isArray(keys) ? keys : [keys];
+            const value = values.map((key) => process.env[key]).find(Boolean);
+            if (!value) {
+                throw new Error(`Missing ${values.join(' or ')}. Provide ClickHouse connection info via environment variables when using --no-interactive.`);
             }
-            return [2 /*return*/, promptClickHouseConnection()];
-        });
-    });
+            return value;
+        };
+        return {
+            host: required(['CLICKHOUSE_URL', 'CLICKHOUSE_HOST']),
+            database: required('CLICKHOUSE_DATABASE'),
+            username: required(['CLICKHOUSE_USERNAME', 'CLICKHOUSE_USER']),
+            password: process.env.CLICKHOUSE_PASSWORD ?? '',
+        };
+    }
+    return promptClickHouseConnection();
+}
+async function testConnection(connectionConfig) {
+    const spinner = ora('Testing connection...').start();
+    process.env.CLICKHOUSE_URL = connectionConfig.host;
+    process.env.CLICKHOUSE_HOST = connectionConfig.host;
+    process.env.CLICKHOUSE_DATABASE = connectionConfig.database;
+    process.env.CLICKHOUSE_USERNAME = connectionConfig.username;
+    process.env.CLICKHOUSE_PASSWORD = connectionConfig.password;
+    const isValid = await validateConnection('clickhouse');
+    if (!isValid) {
+        spinner.fail('Connection failed');
+        logger.newline();
+        logger.error(`Could not connect to ClickHouse at ${connectionConfig.host}`);
+        logger.newline();
+        logger.info('Common issues:');
+        logger.indent('• Check your host URL includes http:// or https://');
+        logger.indent('• Verify username and password');
+        logger.indent('• Ensure database exists');
+        logger.indent('• Check firewall/network access');
+        logger.newline();
+        return { hasValidConnection: false, tableCount: 0 };
+    }
+    const tableCount = await getTableCount('clickhouse');
+    spinner.succeed(`Connected successfully (${tableCount} tables found)`);
+    logger.newline();
+    return { hasValidConnection: true, tableCount };
 }
-function testConnection(connectionConfig) {
-    return __awaiter(this, void 0, void 0, function () {
-        var spinner, isValid, tableCount;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    spinner = ora('Testing connection...').start();
-                    process.env.CLICKHOUSE_URL = connectionConfig.host;
-                    process.env.CLICKHOUSE_HOST = connectionConfig.host;
-                    process.env.CLICKHOUSE_DATABASE = connectionConfig.database;
-                    process.env.CLICKHOUSE_USERNAME = connectionConfig.username;
-                    process.env.CLICKHOUSE_PASSWORD = connectionConfig.password;
-                    return [4 /*yield*/, validateConnection('clickhouse')];
-                case 1:
-                    isValid = _a.sent();
-                    if (!isValid) {
-                        spinner.fail('Connection failed');
-                        logger.newline();
-                        logger.error("Could not connect to ClickHouse at ".concat(connectionConfig.host));
-                        logger.newline();
-                        logger.info('Common issues:');
-                        logger.indent('• Check your host URL includes http:// or https://');
-                        logger.indent('• Verify username and password');
-                        logger.indent('• Ensure database exists');
-                        logger.indent('• Check firewall/network access');
-                        logger.newline();
-                        return [2 /*return*/, { hasValidConnection: false, tableCount: 0 }];
-                    }
-                    return [4 /*yield*/, getTableCount('clickhouse')];
-                case 2:
-                    tableCount = _a.sent();
-                    spinner.succeed("Connected successfully (".concat(tableCount, " tables found)"));
-                    logger.newline();
-                    return [2 /*return*/, { hasValidConnection: true, tableCount: tableCount }];
+export async function initCommand(options = {}) {
+    const noInteractive = options.noInteractive === true || options.interactive === false;
+    logger.newline();
+    logger.header('Welcome to hypequery!');
+    logger.info("Let's set up your analytics layer.");
+    logger.newline();
+    // Step 2: Get connection details
+    let connectionConfig = await resolveConnectionConfig(options);
+    let hasValidConnection = false;
+    // Handle user skipping connection details
+    if (!connectionConfig) {
+        logger.info('Skipping database connection for now.');
+        logger.newline();
+    }
+    else if (options.skipConnection) {
+        logger.info('Skipping database connection test (requested).');
+        logger.newline();
+    }
+    else {
+        const { hasValidConnection: valid } = await testConnection(connectionConfig);
+        hasValidConnection = valid;
+        if (!hasValidConnection) {
+            if (noInteractive) {
+                throw new Error('Failed to connect to ClickHouse in non-interactive mode. Check your environment variables or use interactive setup.');
+            }
+            const retry = await promptRetry('Try again?');
+            if (retry) {
+                return initCommand(options);
+            }
+            const continueWithout = await promptContinueWithoutDb();
+            if (!continueWithout) {
+                logger.info('Setup cancelled');
+                process.exit(0);
             }
-        });
-    });
+            logger.newline();
+            logger.info('Continuing without database connection.');
+            logger.info('You can configure the connection later in .env');
+            logger.newline();
+            connectionConfig = null;
+        }
+    }
+    // Step 4: Get output directory
+    let outputDir = options.path;
+    if (!outputDir && !noInteractive) {
+        outputDir = await promptOutputDirectory();
+    }
+    else if (!outputDir) {
+        outputDir = 'analytics';
+    }
+    const resolvedOutputDir = path.resolve(process.cwd(), outputDir);
+    let style = normalizeInitStyle(options.style);
+    const auth = normalizeAuthMode(options.auth);
+    if (!options.style && !noInteractive) {
+        style = await promptInitStyle();
+    }
+    // Step 5: Check for existing files
+    const filesToCreate = [
+        path.join(resolvedOutputDir, 'client.ts'),
+        path.join(resolvedOutputDir, 'schema.ts'),
+        ...(style === 'datasets'
+            ? [
+                path.join(resolvedOutputDir, 'datasets.ts'),
+                path.join(resolvedOutputDir, 'api.ts'),
+            ]
+            : [
+                path.join(resolvedOutputDir, 'queries.ts'),
+            ]),
+    ];
+    const existingFiles = [];
+    for (const file of filesToCreate) {
+        try {
+            await access(file);
+            existingFiles.push(path.relative(process.cwd(), file));
+        }
+        catch {
+            // File doesn't exist, continue
+        }
+    }
+    if (existingFiles.length > 0 && !options.force) {
+        logger.warn('Files already exist');
+        logger.newline();
+        const shouldOverwrite = noInteractive ? false : await confirmOverwrite(existingFiles);
+        if (!shouldOverwrite) {
+            logger.info('Setup cancelled');
+            process.exit(0);
+        }
+        logger.newline();
+    }
+    // Step 6: Ask about example query (only if we have a valid connection)
+    let generateExample = !options.noExample && hasValidConnection;
+    let selectedTable = null;
+    let discoveredTables = null;
+    if (generateExample && !noInteractive && hasValidConnection) {
+        generateExample = await promptGenerateExample();
+        if (generateExample) {
+            discoveredTables = await getTables('clickhouse');
+            selectedTable = await promptTableSelection(discoveredTables);
+            generateExample = selectedTable !== null;
+        }
+    }
+    let datasetTables = parseTableList(options.tables);
+    const excludedDatasetTables = parseTableList(options.excludeTables);
+    if (style === 'datasets' &&
+        hasValidConnection &&
+        !options.allTables &&
+        !datasetTables &&
+        !noInteractive) {
+        discoveredTables ??= await getTables('clickhouse');
+        datasetTables = await promptDatasetTableSelection(discoveredTables, selectedTable ? [selectedTable] : []);
+    }
+    logger.newline();
+    // Step 7: Create directory
+    await mkdir(resolvedOutputDir, { recursive: true });
+    // Step 8: Save credentials to .env (if we have connection config)
+    if (connectionConfig) {
+        const envPath = path.join(process.cwd(), '.env');
+        const envExists = await hasEnvFile();
+        if (envExists) {
+            const existingEnv = await readFile(envPath, 'utf-8');
+            const newEnv = appendToEnv(existingEnv, generateEnvTemplate(connectionConfig));
+            await writeFile(envPath, newEnv);
+            logger.success('Updated .env');
+        }
+        else {
+            await writeFile(envPath, generateEnvTemplate(connectionConfig));
+            logger.success('Created .env');
+        }
+    }
+    else {
+        // Create placeholder .env
+        const envPath = path.join(process.cwd(), '.env');
+        const envExists = await hasEnvFile();
+        const placeholderConfig = {
+            url: 'YOUR_CLICKHOUSE_URL',
+            database: 'YOUR_DATABASE',
+            username: 'YOUR_USERNAME',
+            password: 'YOUR_PASSWORD',
+        };
+        if (!envExists) {
+            await writeFile(envPath, generateEnvTemplate(placeholderConfig));
+            logger.success('Created .env (configure your credentials)');
+        }
+    }
+    // Step 9: Generate types from schema (only if we have a valid connection)
+    const schemaPath = path.join(resolvedOutputDir, 'schema.ts');
+    if (hasValidConnection) {
+        const typeSpinner = ora('Generating TypeScript types...').start();
+        try {
+            const generator = getTypeGenerator('clickhouse');
+            await generator({ outputPath: schemaPath });
+            typeSpinner.succeed(`Generated TypeScript types (${path.relative(process.cwd(), schemaPath)})`);
+        }
+        catch (error) {
+            typeSpinner.fail('Failed to generate types');
+            logger.error(error instanceof Error ? error.message : String(error));
+            process.exit(1);
+        }
+    }
+    else {
+        // Create placeholder schema file
+        await writeFile(schemaPath, `// Generated by hypequery
+// Run 'npx hypequery generate' after configuring your database connection
+
+export interface IntrospectedSchema {
+  // Your table types will appear here after generation
 }
-export function initCommand() {
-    return __awaiter(this, arguments, void 0, function (options) {
-        var noInteractive, connectionConfig, hasValidConnection, tableCount, _a, valid, count, retry, continueWithout, outputDir, resolvedOutputDir, filesToCreate, existingFiles, _i, filesToCreate_1, file, _b, shouldOverwrite, _c, generateExample, selectedTable, tables, envPath, envExists, existingEnv, newEnv, envPath, envExists, placeholderConfig, schemaPath, typeSpinner, generator, error_1, clientPath, queriesPath, gitignorePath, gitignoreExists, existingGitignore, newGitignore, exampleQueryKey;
-        if (options === void 0) { options = {}; }
-        return __generator(this, function (_d) {
-            switch (_d.label) {
-                case 0:
-                    noInteractive = options.noInteractive === true || options.interactive === false;
-                    logger.newline();
-                    logger.header('Welcome to hypequery!');
-                    logger.info("Let's set up your analytics layer.");
-                    logger.newline();
-                    return [4 /*yield*/, resolveConnectionConfig(options)];
-                case 1:
-                    connectionConfig = _d.sent();
-                    hasValidConnection = false;
-                    tableCount = 0;
-                    if (!!connectionConfig) return [3 /*break*/, 2];
-                    logger.info('Skipping database connection for now.');
-                    logger.newline();
-                    return [3 /*break*/, 7];
-                case 2:
-                    if (!options.skipConnection) return [3 /*break*/, 3];
-                    logger.info('Skipping database connection test (requested).');
-                    logger.newline();
-                    return [3 /*break*/, 7];
-                case 3: return [4 /*yield*/, testConnection(connectionConfig)];
-                case 4:
-                    _a = _d.sent(), valid = _a.hasValidConnection, count = _a.tableCount;
-                    hasValidConnection = valid;
-                    tableCount = count;
-                    if (!!hasValidConnection) return [3 /*break*/, 7];
-                    if (noInteractive) {
-                        throw new Error('Failed to connect to ClickHouse in non-interactive mode. Check your environment variables or use interactive setup.');
-                    }
-                    return [4 /*yield*/, promptRetry('Try again?')];
-                case 5:
-                    retry = _d.sent();
-                    if (retry) {
-                        return [2 /*return*/, initCommand(options)];
-                    }
-                    return [4 /*yield*/, promptContinueWithoutDb()];
-                case 6:
-                    continueWithout = _d.sent();
-                    if (!continueWithout) {
-                        logger.info('Setup cancelled');
-                        process.exit(0);
-                    }
-                    logger.newline();
-                    logger.info('Continuing without database connection.');
-                    logger.info('You can configure the connection later in .env');
-                    logger.newline();
-                    connectionConfig = null;
-                    _d.label = 7;
-                case 7:
-                    outputDir = options.path;
-                    if (!(!outputDir && !noInteractive)) return [3 /*break*/, 9];
-                    return [4 /*yield*/, promptOutputDirectory()];
-                case 8:
-                    outputDir = _d.sent();
-                    return [3 /*break*/, 10];
-                case 9:
-                    if (!outputDir) {
-                        outputDir = 'analytics';
-                    }
-                    _d.label = 10;
-                case 10:
-                    resolvedOutputDir = path.resolve(process.cwd(), outputDir);
-                    filesToCreate = [
-                        path.join(resolvedOutputDir, 'client.ts'),
-                        path.join(resolvedOutputDir, 'schema.ts'),
-                        path.join(resolvedOutputDir, 'queries.ts'),
-                    ];
-                    existingFiles = [];
-                    _i = 0, filesToCreate_1 = filesToCreate;
-                    _d.label = 11;
-                case 11:
-                    if (!(_i < filesToCreate_1.length)) return [3 /*break*/, 16];
-                    file = filesToCreate_1[_i];
-                    _d.label = 12;
-                case 12:
-                    _d.trys.push([12, 14, , 15]);
-                    return [4 /*yield*/, access(file)];
-                case 13:
-                    _d.sent();
-                    existingFiles.push(path.relative(process.cwd(), file));
-                    return [3 /*break*/, 15];
-                case 14:
-                    _b = _d.sent();
-                    return [3 /*break*/, 15];
-                case 15:
-                    _i++;
-                    return [3 /*break*/, 11];
-                case 16:
-                    if (!(existingFiles.length > 0 && !options.force)) return [3 /*break*/, 20];
-                    logger.warn('Files already exist');
-                    logger.newline();
-                    if (!noInteractive) return [3 /*break*/, 17];
-                    _c = false;
-                    return [3 /*break*/, 19];
-                case 17: return [4 /*yield*/, confirmOverwrite(existingFiles)];
-                case 18:
-                    _c = _d.sent();
-                    _d.label = 19;
-                case 19:
-                    shouldOverwrite = _c;
-                    if (!shouldOverwrite) {
-                        logger.info('Setup cancelled');
-                        process.exit(0);
-                    }
-                    logger.newline();
-                    _d.label = 20;
-                case 20:
-                    generateExample = !options.noExample && hasValidConnection;
-                    selectedTable = null;
-                    if (!(generateExample && !noInteractive && hasValidConnection)) return [3 /*break*/, 24];
-                    return [4 /*yield*/, promptGenerateExample()];
-                case 21:
-                    generateExample = _d.sent();
-                    if (!generateExample) return [3 /*break*/, 24];
-                    return [4 /*yield*/, getTables('clickhouse')];
-                case 22:
-                    tables = _d.sent();
-                    return [4 /*yield*/, promptTableSelection(tables)];
-                case 23:
-                    selectedTable = _d.sent();
-                    generateExample = selectedTable !== null;
-                    _d.label = 24;
-                case 24:
-                    logger.newline();
-                    // Step 7: Create directory
-                    return [4 /*yield*/, mkdir(resolvedOutputDir, { recursive: true })];
-                case 25:
-                    // Step 7: Create directory
-                    _d.sent();
-                    if (!connectionConfig) return [3 /*break*/, 32];
-                    envPath = path.join(process.cwd(), '.env');
-                    return [4 /*yield*/, hasEnvFile()];
-                case 26:
-                    envExists = _d.sent();
-                    if (!envExists) return [3 /*break*/, 29];
-                    return [4 /*yield*/, readFile(envPath, 'utf-8')];
-                case 27:
-                    existingEnv = _d.sent();
-                    newEnv = appendToEnv(existingEnv, generateEnvTemplate(connectionConfig));
-                    return [4 /*yield*/, writeFile(envPath, newEnv)];
-                case 28:
-                    _d.sent();
-                    logger.success('Updated .env');
-                    return [3 /*break*/, 31];
-                case 29: return [4 /*yield*/, writeFile(envPath, generateEnvTemplate(connectionConfig))];
-                case 30:
-                    _d.sent();
-                    logger.success('Created .env');
-                    _d.label = 31;
-                case 31: return [3 /*break*/, 35];
-                case 32:
-                    envPath = path.join(process.cwd(), '.env');
-                    return [4 /*yield*/, hasEnvFile()];
-                case 33:
-                    envExists = _d.sent();
-                    placeholderConfig = {
-                        url: 'YOUR_CLICKHOUSE_URL',
-                        database: 'YOUR_DATABASE',
-                        username: 'YOUR_USERNAME',
-                        password: 'YOUR_PASSWORD',
-                    };
-                    if (!!envExists) return [3 /*break*/, 35];
-                    return [4 /*yield*/, writeFile(envPath, generateEnvTemplate(placeholderConfig))];
-                case 34:
-                    _d.sent();
-                    logger.success('Created .env (configure your credentials)');
-                    _d.label = 35;
-                case 35:
-                    schemaPath = path.join(resolvedOutputDir, 'schema.ts');
-                    if (!hasValidConnection) return [3 /*break*/, 40];
-                    typeSpinner = ora('Generating TypeScript types...').start();
-                    _d.label = 36;
-                case 36:
-                    _d.trys.push([36, 38, , 39]);
-                    generator = getTypeGenerator('clickhouse');
-                    return [4 /*yield*/, generator({ outputPath: schemaPath })];
-                case 37:
-                    _d.sent();
-                    typeSpinner.succeed("Generated TypeScript types (".concat(path.relative(process.cwd(), schemaPath), ")"));
-                    return [3 /*break*/, 39];
-                case 38:
-                    error_1 = _d.sent();
-                    typeSpinner.fail('Failed to generate types');
-                    logger.error(error_1 instanceof Error ? error_1.message : String(error_1));
-                    process.exit(1);
-                    return [3 /*break*/, 39];
-                case 39: return [3 /*break*/, 42];
-                case 40: 
-                // Create placeholder schema file
-                return [4 /*yield*/, writeFile(schemaPath, "// Generated by hypequery\n// Run 'npx hypequery generate' after configuring your database connection\n\nexport interface IntrospectedSchema {\n  // Your table types will appear here after generation\n}\n")];
-                case 41:
-                    // Create placeholder schema file
-                    _d.sent();
-                    logger.success("Created placeholder schema (".concat(path.relative(process.cwd(), schemaPath), ")"));
-                    _d.label = 42;
-                case 42:
-                    clientPath = path.join(resolvedOutputDir, 'client.ts');
-                    return [4 /*yield*/, writeFile(clientPath, generateClientTemplate())];
-                case 43:
-                    _d.sent();
-                    logger.success("Created ClickHouse client (".concat(path.relative(process.cwd(), clientPath), ")"));
-                    queriesPath = path.join(resolvedOutputDir, 'queries.ts');
-                    return [4 /*yield*/, writeFile(queriesPath, generateQueriesTemplate({
-                            hasExample: generateExample,
-                            tableName: selectedTable || undefined,
-                        }))];
-                case 44:
-                    _d.sent();
-                    logger.success("Created queries file (".concat(path.relative(process.cwd(), queriesPath), ")"));
-                    if (generateExample && selectedTable) {
-                        logger.success("Created example query using '".concat(selectedTable, "' table"));
-                    }
-                    gitignorePath = path.join(process.cwd(), '.gitignore');
-                    return [4 /*yield*/, hasGitignore()];
-                case 45:
-                    gitignoreExists = _d.sent();
-                    if (!gitignoreExists) return [3 /*break*/, 49];
-                    return [4 /*yield*/, readFile(gitignorePath, 'utf-8')];
-                case 46:
-                    existingGitignore = _d.sent();
-                    newGitignore = appendToGitignore(existingGitignore);
-                    if (!(newGitignore !== existingGitignore)) return [3 /*break*/, 48];
-                    return [4 /*yield*/, writeFile(gitignorePath, newGitignore)];
-                case 47:
-                    _d.sent();
-                    logger.success('Updated .gitignore');
-                    _d.label = 48;
-                case 48: return [3 /*break*/, 51];
-                case 49: return [4 /*yield*/, writeFile(gitignorePath, appendToGitignore(''))];
-                case 50:
-                    _d.sent();
-                    logger.success('Created .gitignore');
-                    _d.label = 51;
-                case 51: 
-                // Step 13: Ensure required hypequery packages are installed
-                return [4 /*yield*/, installScaffoldDependencies()];
-                case 52:
-                    // Step 13: Ensure required hypequery packages are installed
-                    _d.sent();
-                    // Step 14: Success message
-                    logger.newline();
-                    logger.header('Setup complete!');
-                    if (hasValidConnection) {
-                        logger.info('Try your first query:');
-                        logger.newline();
-                        logger.indent("import { api } from './".concat(path.relative(process.cwd(), queriesPath).replace(/\.ts$/, '.js'), "'"));
-                        exampleQueryKey = generateExample && selectedTable
-                            ? "".concat(selectedTable.replace(/_([a-z])/g, function (_, l) { return l.toUpperCase(); }), "Query")
-                            : 'exampleMetric';
-                        logger.indent("const result = await api.execute('".concat(exampleQueryKey, "')"));
-                        logger.newline();
-                        logger.info('Next:');
-                        logger.indent('npx hypequery dev          Start development server');
-                        logger.newline();
-                    }
-                    else {
-                        logger.info('Next steps:');
-                        logger.newline();
-                        logger.indent('1. Configure your database connection in .env');
-                        logger.indent('2. Run: npx hypequery generate    (to generate types)');
-                        logger.indent('3. Run: npx hypequery dev          (to start dev server)');
-                        logger.newline();
-                    }
-                    logger.info('Docs: https://hypequery.com/docs');
-                    logger.newline();
-                    return [2 /*return*/];
+`);
+        logger.success(`Created placeholder schema (${path.relative(process.cwd(), schemaPath)})`);
+    }
+    // Step 10: Create client.ts
+    const clientPath = path.join(resolvedOutputDir, 'client.ts');
+    await writeFile(clientPath, generateClientTemplate());
+    logger.success(`Created ClickHouse client (${path.relative(process.cwd(), clientPath)})`);
+    // Step 11: Create API entrypoint
+    let apiPath;
+    let generatedAnyDatasets = false;
+    let generatedSelectedDataset = false;
+    if (style === 'datasets') {
+        const datasetsPath = path.join(resolvedOutputDir, 'datasets.ts');
+        const shouldGenerateDatasets = hasValidConnection && (options.allTables === true ||
+            (datasetTables !== undefined && datasetTables.length > 0));
+        if (shouldGenerateDatasets) {
+            await generateDatasets({
+                outputPath: datasetsPath,
+                includeTables: options.allTables ? undefined : datasetTables,
+                excludeTables: excludedDatasetTables,
+            });
+            generatedAnyDatasets = true;
+            generatedSelectedDataset = selectedTable !== null && (options.allTables === true ||
+                datasetTables?.includes(selectedTable) === true);
+        }
+        else {
+            await writeFile(datasetsPath, generateDatasetsPlaceholderTemplate());
+            if (hasValidConnection) {
+                logger.info('Skipped dataset generation. Run `hypequery generate:datasets --path ' + outputDir + ' --tables table1,table2` when ready.');
             }
-        });
-    });
+        }
+        logger.success(`Created datasets file (${path.relative(process.cwd(), datasetsPath)})`);
+        apiPath = path.join(resolvedOutputDir, 'api.ts');
+        await writeFile(apiPath, generateApiTemplate({ auth }));
+        logger.success(`Created API file (${path.relative(process.cwd(), apiPath)})`);
+    }
+    else {
+        apiPath = path.join(resolvedOutputDir, 'queries.ts');
+        await writeFile(apiPath, generateQueriesTemplate({
+            hasExample: generateExample,
+            tableName: selectedTable || undefined,
+            auth,
+        }));
+        logger.success(`Created queries file (${path.relative(process.cwd(), apiPath)})`);
+    }
+    if (generateExample && selectedTable && (style === 'queries' || generatedSelectedDataset)) {
+        logger.success(`Created example ${style === 'datasets' ? 'dataset' : 'query'} using '${selectedTable}' table`);
+    }
+    // Step 12: Update .gitignore
+    const gitignorePath = path.join(process.cwd(), '.gitignore');
+    const gitignoreExists = await hasGitignore();
+    if (gitignoreExists) {
+        const existingGitignore = await readFile(gitignorePath, 'utf-8');
+        const newGitignore = appendToGitignore(existingGitignore);
+        if (newGitignore !== existingGitignore) {
+            await writeFile(gitignorePath, newGitignore);
+            logger.success('Updated .gitignore');
+        }
+    }
+    else {
+        await writeFile(gitignorePath, appendToGitignore(''));
+        logger.success('Created .gitignore');
+    }
+    // Step 13: Ensure required hypequery packages are installed
+    await installScaffoldDependencies(style);
+    // Step 14: Success message
+    logger.newline();
+    logger.header('Setup complete!');
+    if (hasValidConnection) {
+        if (style === 'datasets' && !generatedAnyDatasets) {
+            logger.info('Next:');
+            logger.indent(`hypequery generate:datasets --path ${outputDir} --tables table1,table2`);
+            logger.newline();
+        }
+        else if (style === 'datasets' && !generatedSelectedDataset) {
+            logger.info('Next:');
+            logger.indent('npx hypequery dev          Start development server');
+            logger.newline();
+        }
+        else {
+            logger.info('Try your first query:');
+            logger.newline();
+            logger.indent(`import { api } from './${path.relative(process.cwd(), apiPath).replace(/\.ts$/, '.js')}'`);
+            const exampleQueryKey = generateExample && selectedTable
+                ? `${selectedTable.replace(/_([a-z])/g, (_, l) => l.toUpperCase())}Query`
+                : 'exampleMetric';
+            if (style === 'datasets' && selectedTable) {
+                logger.indent(`const result = await api.execute('dataset:${selectedTable}', { input: {} })`);
+            }
+            else {
+                logger.indent(`const result = await api.execute('${exampleQueryKey}')`);
+            }
+            logger.newline();
+            logger.info('Next:');
+            logger.indent('npx hypequery dev          Start development server');
+            logger.newline();
+        }
+    }
+    else {
+        logger.info('Next steps:');
+        logger.newline();
+        logger.indent('1. Configure your database connection in .env');
+        logger.indent('2. Run: npx hypequery generate    (to generate types)');
+        logger.indent('3. Run: npx hypequery dev          (to start dev server)');
+        logger.newline();
+    }
+    logger.info('Docs: https://hypequery.com/docs');
+    logger.newline();
 }