@hypequery/cli 1.1.0 → 1.1.2

package/dist/commands/init.js

@@ -38,7 +38,7 @@ 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 { promptDatabaseType, promptClickHouseConnection, promptOutputDirectory, promptGenerateExample, promptTableSelection, confirmOverwrite, promptRetry, promptContinueWithoutDb, } from '../utils/prompts.js';
+import { promptClickHouseConnection, promptOutputDirectory, promptGenerateExample, promptTableSelection, 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';
@@ -46,53 +46,25 @@ import { generateClientTemplate } from '../templates/client.js';
 import { generateQueriesTemplate } from '../templates/queries.js';
 import { appendToGitignore } from '../templates/gitignore.js';
 import { getTypeGenerator } from '../generators/index.js';
-import { installServeDependencies } from '../utils/dependency-installer.js';
-function determineDatabase(options) {
-    return __awaiter(this, void 0, void 0, function () {
-        var dbType, _a;
-        var _b;
-        return __generator(this, function (_c) {
-            switch (_c.label) {
-                case 0:
-                    if (!((_b = options.database) !== null && _b !== void 0)) return [3 /*break*/, 1];
-                    _a = _b;
-                    return [3 /*break*/, 3];
-                case 1: return [4 /*yield*/, promptDatabaseType()];
-                case 2:
-                    _a = (_c.sent());
-                    _c.label = 3;
-                case 3:
-                    dbType = _a;
-                    if (!dbType) {
-                        logger.info('Setup cancelled');
-                        process.exit(0);
-                    }
-                    if (dbType !== 'clickhouse') {
-                        logger.error("".concat(dbType, " is not yet supported. Only ClickHouse is available."));
-                        process.exit(1);
-                    }
-                    return [2 /*return*/, dbType];
-            }
-        });
-    });
-}
+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 (key) {
-                    var value = process.env[key];
+                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(key, ". Provide ClickHouse connection info via environment variables when using --no-interactive."));
+                        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_HOST'),
+                        host: required(['CLICKHOUSE_URL', 'CLICKHOUSE_HOST']),
                         database: required('CLICKHOUSE_DATABASE'),
-                        username: required('CLICKHOUSE_USERNAME'),
+                        username: required(['CLICKHOUSE_USERNAME', 'CLICKHOUSE_USER']),
                         password: (_a = process.env.CLICKHOUSE_PASSWORD) !== null && _a !== void 0 ? _a : '',
                     }];
             }
@@ -100,18 +72,19 @@ function resolveConnectionConfig(options) {
         });
     });
 }
-function testConnection(connectionConfig, dbType) {
+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(dbType)];
+                    return [4 /*yield*/, validateConnection('clickhouse')];
                 case 1:
                     isValid = _a.sent();
                     if (!isValid) {
@@ -127,7 +100,7 @@ function testConnection(connectionConfig, dbType) {
                         logger.newline();
                         return [2 /*return*/, { hasValidConnection: false, tableCount: 0 }];
                     }
-                    return [4 /*yield*/, getTableCount(dbType)];
+                    return [4 /*yield*/, getTableCount('clickhouse')];
                 case 2:
                     tableCount = _a.sent();
                     spinner.succeed("Connected successfully (".concat(tableCount, " tables found)"));
@@ -139,47 +112,48 @@ function testConnection(connectionConfig, dbType) {
 }
 export function initCommand() {
     return __awaiter(this, arguments, void 0, function (options) {
-        var dbType, connectionConfig, hasValidConnection, tableCount, _a, valid, count, retry, continueWithout, outputDir, resolvedOutputDir, filesToCreate, existingFiles, _i, filesToCreate_1, file, _b, shouldOverwrite, generateExample, selectedTable, tables, envPath, envExists, existingEnv, newEnv, envPath, envExists, placeholderConfig, schemaPath, typeSpinner, generator, error_1, clientPath, queriesPath, gitignorePath, gitignoreExists, existingGitignore, newGitignore, exampleQueryKey;
+        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 (_c) {
-            switch (_c.label) {
+        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*/, determineDatabase(options)];
-                case 1:
-                    dbType = _c.sent();
                     return [4 /*yield*/, resolveConnectionConfig(options)];
-                case 2:
-                    connectionConfig = _c.sent();
+                case 1:
+                    connectionConfig = _d.sent();
                     hasValidConnection = false;
                     tableCount = 0;
-                    if (!!connectionConfig) return [3 /*break*/, 3];
+                    if (!!connectionConfig) return [3 /*break*/, 2];
                     logger.info('Skipping database connection for now.');
                     logger.newline();
-                    return [3 /*break*/, 8];
-                case 3:
-                    if (!options.skipConnection) return [3 /*break*/, 4];
+                    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*/, 8];
-                case 4: return [4 /*yield*/, testConnection(connectionConfig, dbType)];
-                case 5:
-                    _a = _c.sent(), valid = _a.hasValidConnection, count = _a.tableCount;
+                    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*/, 8];
+                    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 6:
-                    retry = _c.sent();
+                case 5:
+                    retry = _d.sent();
                     if (retry) {
                         return [2 /*return*/, initCommand(options)];
                     }
                     return [4 /*yield*/, promptContinueWithoutDb()];
-                case 7:
-                    continueWithout = _c.sent();
+                case 6:
+                    continueWithout = _d.sent();
                     if (!continueWithout) {
                         logger.info('Setup cancelled');
                         process.exit(0);
@@ -189,20 +163,20 @@ export function initCommand() {
                     logger.info('You can configure the connection later in .env');
                     logger.newline();
                     connectionConfig = null;
-                    _c.label = 8;
-                case 8:
+                    _d.label = 7;
+                case 7:
                     outputDir = options.path;
-                    if (!(!outputDir && !options.noInteractive)) return [3 /*break*/, 10];
+                    if (!(!outputDir && !noInteractive)) return [3 /*break*/, 9];
                     return [4 /*yield*/, promptOutputDirectory()];
+                case 8:
+                    outputDir = _d.sent();
+                    return [3 /*break*/, 10];
                 case 9:
-                    outputDir = _c.sent();
-                    return [3 /*break*/, 11];
-                case 10:
                     if (!outputDir) {
                         outputDir = 'analytics';
                     }
-                    _c.label = 11;
-                case 11:
+                    _d.label = 10;
+                case 10:
                     resolvedOutputDir = path.resolve(process.cwd(), outputDir);
                     filesToCreate = [
                         path.join(resolvedOutputDir, 'client.ts'),
@@ -211,170 +185,176 @@ export function initCommand() {
                     ];
                     existingFiles = [];
                     _i = 0, filesToCreate_1 = filesToCreate;
-                    _c.label = 12;
-                case 12:
-                    if (!(_i < filesToCreate_1.length)) return [3 /*break*/, 17];
+                    _d.label = 11;
+                case 11:
+                    if (!(_i < filesToCreate_1.length)) return [3 /*break*/, 16];
                     file = filesToCreate_1[_i];
-                    _c.label = 13;
-                case 13:
-                    _c.trys.push([13, 15, , 16]);
+                    _d.label = 12;
+                case 12:
+                    _d.trys.push([12, 14, , 15]);
                     return [4 /*yield*/, access(file)];
-                case 14:
-                    _c.sent();
+                case 13:
+                    _d.sent();
                     existingFiles.push(path.relative(process.cwd(), file));
-                    return [3 /*break*/, 16];
+                    return [3 /*break*/, 15];
+                case 14:
+                    _b = _d.sent();
+                    return [3 /*break*/, 15];
                 case 15:
-                    _b = _c.sent();
-                    return [3 /*break*/, 16];
-                case 16:
                     _i++;
-                    return [3 /*break*/, 12];
-                case 17:
-                    if (!(existingFiles.length > 0 && !options.force)) return [3 /*break*/, 19];
+                    return [3 /*break*/, 11];
+                case 16:
+                    if (!(existingFiles.length > 0 && !options.force)) return [3 /*break*/, 20];
                     logger.warn('Files already exist');
                     logger.newline();
-                    return [4 /*yield*/, confirmOverwrite(existingFiles)];
+                    if (!noInteractive) return [3 /*break*/, 17];
+                    _c = false;
+                    return [3 /*break*/, 19];
+                case 17: return [4 /*yield*/, confirmOverwrite(existingFiles)];
                 case 18:
-                    shouldOverwrite = _c.sent();
+                    _c = _d.sent();
+                    _d.label = 19;
+                case 19:
+                    shouldOverwrite = _c;
                     if (!shouldOverwrite) {
                         logger.info('Setup cancelled');
                         process.exit(0);
                     }
                     logger.newline();
-                    _c.label = 19;
-                case 19:
+                    _d.label = 20;
+                case 20:
                     generateExample = !options.noExample && hasValidConnection;
                     selectedTable = null;
-                    if (!(generateExample && !options.noInteractive && hasValidConnection)) return [3 /*break*/, 23];
+                    if (!(generateExample && !noInteractive && hasValidConnection)) return [3 /*break*/, 24];
                     return [4 /*yield*/, promptGenerateExample()];
-                case 20:
-                    generateExample = _c.sent();
-                    if (!generateExample) return [3 /*break*/, 23];
-                    return [4 /*yield*/, getTables(dbType)];
                 case 21:
-                    tables = _c.sent();
-                    return [4 /*yield*/, promptTableSelection(tables)];
+                    generateExample = _d.sent();
+                    if (!generateExample) return [3 /*break*/, 24];
+                    return [4 /*yield*/, getTables('clickhouse')];
                 case 22:
-                    selectedTable = _c.sent();
-                    generateExample = selectedTable !== null;
-                    _c.label = 23;
+                    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 24:
+                case 25:
                     // Step 7: Create directory
-                    _c.sent();
-                    if (!connectionConfig) return [3 /*break*/, 31];
+                    _d.sent();
+                    if (!connectionConfig) return [3 /*break*/, 32];
                     envPath = path.join(process.cwd(), '.env');
                     return [4 /*yield*/, hasEnvFile()];
-                case 25:
-                    envExists = _c.sent();
-                    if (!envExists) return [3 /*break*/, 28];
-                    return [4 /*yield*/, readFile(envPath, 'utf-8')];
                 case 26:
-                    existingEnv = _c.sent();
+                    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 27:
-                    _c.sent();
+                case 28:
+                    _d.sent();
                     logger.success('Updated .env');
-                    return [3 /*break*/, 30];
-                case 28: return [4 /*yield*/, writeFile(envPath, generateEnvTemplate(connectionConfig))];
-                case 29:
-                    _c.sent();
+                    return [3 /*break*/, 31];
+                case 29: return [4 /*yield*/, writeFile(envPath, generateEnvTemplate(connectionConfig))];
+                case 30:
+                    _d.sent();
                     logger.success('Created .env');
-                    _c.label = 30;
-                case 30: return [3 /*break*/, 34];
-                case 31:
+                    _d.label = 31;
+                case 31: return [3 /*break*/, 35];
+                case 32:
                     envPath = path.join(process.cwd(), '.env');
                     return [4 /*yield*/, hasEnvFile()];
-                case 32:
-                    envExists = _c.sent();
+                case 33:
+                    envExists = _d.sent();
                     placeholderConfig = {
-                        host: 'YOUR_CLICKHOUSE_HOST',
+                        url: 'YOUR_CLICKHOUSE_URL',
                         database: 'YOUR_DATABASE',
                         username: 'YOUR_USERNAME',
                         password: 'YOUR_PASSWORD',
                     };
-                    if (!!envExists) return [3 /*break*/, 34];
+                    if (!!envExists) return [3 /*break*/, 35];
                     return [4 /*yield*/, writeFile(envPath, generateEnvTemplate(placeholderConfig))];
-                case 33:
-                    _c.sent();
-                    logger.success('Created .env (configure your credentials)');
-                    _c.label = 34;
                 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*/, 39];
+                    if (!hasValidConnection) return [3 /*break*/, 40];
                     typeSpinner = ora('Generating TypeScript types...').start();
-                    _c.label = 35;
-                case 35:
-                    _c.trys.push([35, 37, , 38]);
+                    _d.label = 36;
+                case 36:
+                    _d.trys.push([36, 38, , 39]);
                     generator = getTypeGenerator('clickhouse');
                     return [4 /*yield*/, generator({ outputPath: schemaPath })];
-                case 36:
-                    _c.sent();
-                    typeSpinner.succeed("Generated TypeScript types (".concat(path.relative(process.cwd(), schemaPath), ")"));
-                    return [3 /*break*/, 38];
                 case 37:
-                    error_1 = _c.sent();
+                    _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*/, 38];
-                case 38: return [3 /*break*/, 41];
-                case 39: 
+                    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 40:
+                case 41:
                     // Create placeholder schema file
-                    _c.sent();
+                    _d.sent();
                     logger.success("Created placeholder schema (".concat(path.relative(process.cwd(), schemaPath), ")"));
-                    _c.label = 41;
-                case 41:
+                    _d.label = 42;
+                case 42:
                     clientPath = path.join(resolvedOutputDir, 'client.ts');
                     return [4 /*yield*/, writeFile(clientPath, generateClientTemplate())];
-                case 42:
-                    _c.sent();
+                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 43:
-                    _c.sent();
+                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 44:
-                    gitignoreExists = _c.sent();
-                    if (!gitignoreExists) return [3 /*break*/, 48];
-                    return [4 /*yield*/, readFile(gitignorePath, 'utf-8')];
                 case 45:
-                    existingGitignore = _c.sent();
+                    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*/, 47];
+                    if (!(newGitignore !== existingGitignore)) return [3 /*break*/, 48];
                     return [4 /*yield*/, writeFile(gitignorePath, newGitignore)];
-                case 46:
-                    _c.sent();
+                case 47:
+                    _d.sent();
                     logger.success('Updated .gitignore');
-                    _c.label = 47;
-                case 47: return [3 /*break*/, 50];
-                case 48: return [4 /*yield*/, writeFile(gitignorePath, appendToGitignore(''))];
-                case 49:
-                    _c.sent();
+                    _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');
-                    _c.label = 50;
-                case 50: 
+                    _d.label = 51;
+                case 51: 
                 // Step 13: Ensure required hypequery packages are installed
-                return [4 /*yield*/, installServeDependencies()];
-                case 51:
+                return [4 /*yield*/, installScaffoldDependencies()];
+                case 52:
                     // Step 13: Ensure required hypequery packages are installed
-                    _c.sent();
+                    _d.sent();
                     // Step 14: Success message
                     logger.newline();
                     logger.header('Setup complete!');

package/dist/generators/clickhouse.d.ts

@@ -3,5 +3,7 @@ export interface ClickHouseGeneratorOptions {
     includeTables?: string[];
     excludeTables?: string[];
 }
+declare const clickhouseToTsType: (type: string) => string;
+export { clickhouseToTsType };
 export declare function generateClickHouseTypes(options: ClickHouseGeneratorOptions): Promise<void>;
 //# sourceMappingURL=clickhouse.d.ts.map

package/dist/generators/clickhouse.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"clickhouse.d.ts","sourceRoot":"","sources":["../../src/generators/clickhouse.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,0BAA0B;IACzC,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;CAC1B;AA4HD,wBAAsB,uBAAuB,CAAC,OAAO,EAAE,0BAA0B,iBA0ChF"}
+{"version":3,"file":"clickhouse.d.ts","sourceRoot":"","sources":["../../src/generators/clickhouse.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,0BAA0B;IACzC,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;CAC1B;AAmGD,QAAA,MAAM,kBAAkB,GAAI,MAAM,MAAM,KAAG,MAsC1C,CAAC;AAEF,OAAO,EAAE,kBAAkB,EAAE,CAAC;AAgC9B,wBAAsB,uBAAuB,CAAC,OAAO,EAAE,0BAA0B,iBA0ChF"}

package/dist/generators/clickhouse.js

@@ -39,57 +39,53 @@ import path from 'node:path';
 import { getClickHouseClient } from '../utils/clickhouse-client.js';
 var DEFAULT_WARNING = 'Warning: No tables match the filter criteria. Check your include/exclude options.';
 var capitalizeFirstLetter = function (value) { return value.charAt(0).toUpperCase() + value.slice(1); };
-var clickhouseToTsType = function (type) {
-    if (type.startsWith('Array(')) {
-        var innerType = type.slice(6, -1);
-        return "Array<".concat(clickhouseToTsType(innerType), ">");
-    }
-    if (type.startsWith('Nullable(')) {
-        var innerType = type.slice(9, -1);
-        return "".concat(clickhouseToTsType(innerType), " | null");
-    }
-    if (type.startsWith('Map(')) {
-        var mapContent = type.slice(4, -1);
-        var commaIndex = mapContent.lastIndexOf(',');
-        if (commaIndex !== -1) {
-            var keyType = mapContent.substring(0, commaIndex).trim();
-            var valueType = mapContent.substring(commaIndex + 1).trim();
-            var keyTsType = 'string';
-            if (keyType === 'LowCardinality(String)') {
-                keyTsType = 'string';
-            }
-            else if (keyType.includes('Int') || keyType.includes('UInt')) {
-                keyTsType = 'number';
-            }
-            var valueTsType = 'unknown';
-            if (valueType.startsWith('Array(')) {
-                var innerType = valueType.slice(6, -1);
-                valueTsType = "Array<".concat(clickhouseToTsType(innerType), ">");
-            }
-            else if (valueType.startsWith('Nullable(')) {
-                var innerType = valueType.slice(9, -1);
-                valueTsType = "".concat(clickhouseToTsType(innerType), " | null");
-            }
-            else {
-                valueTsType = clickhouseToTsType(valueType);
-            }
-            return "Record<".concat(keyTsType, ", ").concat(valueTsType, ">");
+function splitTopLevelArgs(value) {
+    var parts = [];
+    var current = '';
+    var depth = 0;
+    for (var _i = 0, value_1 = value; _i < value_1.length; _i++) {
+        var char = value_1[_i];
+        if (char === '(') {
+            depth += 1;
+            current += char;
+            continue;
         }
-        return 'Record<string, unknown>';
+        if (char === ')') {
+            depth -= 1;
+            current += char;
+            continue;
+        }
+        if (char === ',' && depth === 0) {
+            parts.push(current.trim());
+            current = '';
+            continue;
+        }
+        current += char;
     }
-    switch (type.toLowerCase()) {
+    if (current.trim()) {
+        parts.push(current.trim());
+    }
+    return parts;
+}
+function unwrapType(type, wrapperName) {
+    var prefix = "".concat(wrapperName, "(");
+    return type.startsWith(prefix) && type.endsWith(')') ? type.slice(prefix.length, -1) : null;
+}
+function getPrimitiveTsType(type) {
+    var lowerType = type.toLowerCase();
+    switch (lowerType) {
         case 'string':
-        case 'fixedstring':
+        case 'uuid':
             return 'string';
         case 'int8':
         case 'int16':
         case 'int32':
         case 'uint8':
-        case 'int64':
         case 'uint16':
         case 'uint32':
-        case 'uint64':
             return 'number';
+        case 'int64':
+        case 'uint64':
         case 'uint128':
         case 'uint256':
         case 'int128':
@@ -108,9 +104,56 @@ var clickhouseToTsType = function (type) {
         case 'boolean':
             return 'boolean';
         default:
-            return 'string';
+            if (type.startsWith('FixedString('))
+                return 'string';
+            if (type.startsWith('Decimal('))
+                return 'number';
+            if (type.startsWith('DateTime64('))
+                return 'string';
+            if (type.startsWith('DateTime('))
+                return 'string';
+            if (type.startsWith('Enum8('))
+                return 'string';
+            if (type.startsWith('Enum16('))
+                return 'string';
+            return null;
+    }
+}
+var clickhouseToTsType = function (type) {
+    var wrappedArrayType = unwrapType(type, 'Array');
+    if (wrappedArrayType) {
+        return "Array<".concat(clickhouseToTsType(wrappedArrayType), ">");
+    }
+    var wrappedNullableType = unwrapType(type, 'Nullable');
+    if (wrappedNullableType) {
+        return "".concat(clickhouseToTsType(wrappedNullableType), " | null");
+    }
+    var wrappedLowCardinalityType = unwrapType(type, 'LowCardinality');
+    if (wrappedLowCardinalityType) {
+        return clickhouseToTsType(wrappedLowCardinalityType);
+    }
+    var wrappedTupleType = unwrapType(type, 'Tuple');
+    if (wrappedTupleType) {
+        var tupleParts = splitTopLevelArgs(wrappedTupleType);
+        return "[".concat(tupleParts.map(clickhouseToTsType).join(', '), "]");
+    }
+    var wrappedMapType = unwrapType(type, 'Map');
+    if (wrappedMapType) {
+        var mapParts = splitTopLevelArgs(wrappedMapType);
+        if (mapParts.length === 2) {
+            var valueType = mapParts[1];
+            // JSON object keys are strings even when ClickHouse map keys are numeric.
+            return "Record<string, ".concat(clickhouseToTsType(valueType), ">");
+        }
+        return 'Record<string, unknown>';
     }
+    var primitiveType = getPrimitiveTsType(type);
+    if (primitiveType)
+        return primitiveType;
+    // Unsupported or more complex ClickHouse types currently preserve the historical fallback.
+    return 'string';
 };
+export { clickhouseToTsType };
 function fetchTables(includeTables, excludeTables) {
     return __awaiter(this, void 0, void 0, function () {
         var client, tablesQuery, tables;

package/dist/generators/index.js

@@ -6,7 +6,7 @@ export function getTypeGenerator(dbType) {
     var generator = generators[dbType];
     if (!generator) {
         throw new Error(dbType === 'unknown'
-            ? 'Unable to detect database type. Re-run `hypequery init --database <type>` or pass `--database` explicitly.'
+            ? 'Unable to detect database type. Re-run `hypequery generate --database <type>` or pass `--database` explicitly.'
             : "Type generation for ".concat(dbType, " is not supported yet."));
     }
     return generator;